From 50486e574adb22f80f19a20032c6de276c02887a Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Wed, 29 Jul 2020 09:54:11 -0400
Subject: [PATCH 1/4] Implements both Tensor and NdArray interfaces from same
 instance

---
 .../annotations/org/tensorflow/op/Ops.java    |   2 +-
 .../main/java/org/tensorflow/DataType.java    |  26 +--
 .../main/java/org/tensorflow/DataTypes.java   |   8 +-
 .../java/org/tensorflow/EagerOperation.java   |   8 +-
 .../src/main/java/org/tensorflow/Operand.java |   6 +-
 .../src/main/java/org/tensorflow/Output.java  |   4 +-
 .../src/main/java/org/tensorflow/Session.java |   2 +-
 .../src/main/java/org/tensorflow/Tensor.java  | 167 +++---------------
 .../src/main/java/org/tensorflow/Tensors.java |  70 ++++++++
 ...fer.java => ByteSequenceTensorBuffer.java} |  16 +-
 .../internal/buffer/TensorBuffers.java        |   4 +-
 .../buffer/TensorRawDataBufferFactory.java    |   4 +-
 .../java/org/tensorflow/op/core/Constant.java |   4 +-
 .../org/tensorflow/types/BooleanTensor.java   | 126 +++++++++++++
 .../java/org/tensorflow/types/ByteTensor.java | 125 +++++++++++++
 .../org/tensorflow/types/DoubleTensor.java    | 126 +++++++++++++
 .../org/tensorflow/types/FloatTensor.java     | 126 +++++++++++++
 .../java/org/tensorflow/types/IntTensor.java  | 126 +++++++++++++
 .../java/org/tensorflow/types/LongTensor.java | 126 +++++++++++++
 .../java/org/tensorflow/types/RawTensor.java  |  66 +++++++
 .../org/tensorflow/types/StringTensor.java    | 125 +++++++++++++
 .../java/org/tensorflow/types/TBfloat16.java  |  44 +++--
 .../main/java/org/tensorflow/types/TBool.java |  42 ++---
 .../java/org/tensorflow/types/TFloat16.java   |  44 +++--
 .../java/org/tensorflow/types/TFloat32.java   |  44 ++---
 .../java/org/tensorflow/types/TFloat64.java   |  44 ++---
 .../java/org/tensorflow/types/TInt32.java     |  42 ++---
 .../java/org/tensorflow/types/TInt64.java     |  42 ++---
 .../java/org/tensorflow/types/TString.java    |  63 +++----
 .../java/org/tensorflow/types/TUint8.java     |  40 ++---
 .../org/tensorflow/types/family/TFloat.java   |   5 +
 .../test/java/org/tensorflow/TensorTest.java  |   2 +-
 32 files changed, 1270 insertions(+), 409 deletions(-)
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
 rename tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/{StringTensorBuffer.java => ByteSequenceTensorBuffer.java} (91%)
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/RawTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/StringTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.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 1c27b439cec..fa7701af49f 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
@@ -1853,7 +1853,7 @@ public Constant<TString> constant(Charset charset, Shape shape, DataBuffer<Strin
    * @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,
+  public <T extends TType & Tensor> Constant<T> constant(DataType<T> type, Shape shape,
       ByteDataBuffer data) {
     return Constant.tensorOf(scope, type, shape, data);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
index 24bd0826fa8..70edafa391a 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
@@ -23,7 +23,7 @@
 public final class DataType<T extends TType> {
 
   @FunctionalInterface
-  public interface TensorMapper<T> {
+  public interface TensorInstantiator<T> {
 
     /**
      * Maps tensor memory to a data structure for manipulating elements of this type.
@@ -41,10 +41,10 @@ public interface TensorMapper<T> {
    * @param name readable-name for this type
    * @param value must match the corresponding TF_* value in the TensorFlow C API.
    * @param byteSize size of an element of this type, in bytes, -1 if unknown
-   * @param tensorMapper method for mapping tensor memory to elements of this type
+   * @param tensorMapper method for instantiating tensor from a native reference
    */
-  public static <T extends TType> DataType<T> create(String name, int value, int byteSize, TensorMapper<T> tensorMapper) {
-    return new DataType<>(name, value, byteSize, tensorMapper);
+  public static <T extends TType> DataType<T> create(String name, int value, int byteSize, TensorInstantiator<T> instantiator) {
+    return new DataType<>(name, value, byteSize, instantiator);
   }
 
   /**
@@ -76,29 +76,29 @@ public String toString() {
   /**
    * Returns the numeric code for this datatype, as recognized by the native library (C API)
    */
-  int nativeCode() {
+  public int nativeCode() {
     return nativeCode;
   }
 
   /**
-   * Maps a tensor to a data structure for manipulating elements of this type.
+   * Instantiate a tensor of this datatype from the provided native handle
    *
-   * @param tensor tensor to map
-   * @return data structure of elements of this type
+   * @param handle tensor native handle
+   * @return a tensor of this datatype
    */
-  T map(Tensor<T> tensor) {
-    return tensorMapper.apply(tensor.nativeHandle(), tensor.shape());
+  T instantiateTensor(TF_Tensor handle, Shape shape) {
+    return tensorInstantiator.apply(handle, shape);
   }
 
   private final int nativeCode;
   private final int byteSize;
   private final String name;
-  private final TensorMapper<T> tensorMapper;
+  private final TensorInstantiator<T> tensorInstantiator;
 
-  private DataType(String name, int nativeCode, int byteSize, TensorMapper<T> tensorMapper) {
+  private DataType(String name, int nativeCode, int byteSize, TensorInstantiator<T> tensorInstantiator) {
     this.name = name;
     this.nativeCode = nativeCode;
     this.byteSize = byteSize;
-    this.tensorMapper = tensorMapper;
+    this.tensorInstantiator = tensorInstantiator;
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataTypes.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataTypes.java
index 77c0de0c83f..03d613475b5 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataTypes.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataTypes.java
@@ -43,8 +43,8 @@ final class DataTypes {
    * @return data type for this code
    * @throws IllegalArgumentException if the code matches no registered data type
    */
-  static DataType<?> fromNativeCode(int nativeCode) {
-    DataType<?> dataType = DATA_TYPE_REGISTRY.get(nativeCode);
+  static DataType<? extends Tensor> fromNativeCode(int nativeCode) {
+    DataType<? extends Tensor> dataType = DATA_TYPE_REGISTRY.get(nativeCode);
     if (dataType == null) {
       throw new IllegalArgumentException(
           "DataType " + nativeCode + " is not recognized in Java (version " + TensorFlow.version() + ")");
@@ -52,7 +52,7 @@ static DataType<?> fromNativeCode(int nativeCode) {
     return dataType;
   }
 
-  private static final Map<Integer, DataType<?>> DATA_TYPE_REGISTRY = new HashMap<>();
+  private static final Map<Integer, DataType<? extends Tensor>> DATA_TYPE_REGISTRY = new HashMap<>();
 
   static {
     register(TBool.DTYPE);
@@ -68,7 +68,7 @@ static DataType<?> fromNativeCode(int nativeCode) {
 
   // TODO (karllessard): Right now this method is private but we might want to expose it
   //      to allow user to register custom data types?
-  private static void register(DataType<?> dataType) {
+  private static void register(DataType<? extends Tensor> dataType) {
     DATA_TYPE_REGISTRY.put(dataType.nativeCode(), dataType);
     DATA_TYPE_REGISTRY.put(dataType.nativeCode() + 100, dataType);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java
index 012981ac59c..690d5d1a4cb 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java
@@ -162,7 +162,13 @@ private static Tensor<?> resolveTensorHandle(TFE_TensorHandle handle, EagerSessi
       TF_Status status = TF_Status.newStatus();
       TF_Tensor tensor = TFE_TensorHandleResolve(handle, status).withDeallocator();
       status.throwExceptionIfNotOK();
-      return Tensor.fromHandle(tensor, session);
+      Tensor<?> t = Tensors.fromHandle(tensor);
+      session.attach(t.nativeHandle());
+      // Now that the tensor life is attached to the eager session scope, closing it will
+      // implicitly detach it from its previous internal scope
+      // FIXME TENSOR REFACT : is that right and ok?
+      t.close();
+      return t;
     }
   }
 
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 fa21f32d4ce..070fc55cb0f 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
@@ -60,7 +60,7 @@ public interface Operand<T extends TType> extends Op {
    * @return the tensor
    * @throws IllegalStateException if this is an operand of a graph
    */
-  default Tensor<T> asTensor() {
+  default T asTensor() {
     return asOutput().tensor();
   }
 
@@ -72,8 +72,10 @@ default Tensor<T> asTensor() {
    *
    * @return the tensor data
    * @throws IllegalStateException if this is an operand of a graph
+   * @deprecated use {@link #asTensor()} instead
    */
+  @Deprecated
   default T data() {
-    return asOutput().tensor().data();
+    return asTensor();
   }
 }
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 a873df8ff4c..c6499377ded 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
@@ -80,8 +80,8 @@ public <U extends TType> Output<U> expect(DataType<U> dt) {
    * @see EagerSession
    */
   @SuppressWarnings("unchecked")
-  public Tensor<T> tensor() {
-    return (Tensor<T>) operation.tensor(index);
+  public T tensor() {
+    return (T)operation.tensor(index);
   }
 
   @Override
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 0676ce8ec4e..91c4e6b2b7b 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
@@ -596,7 +596,7 @@ private static RunMetadata run(
 
       for (int i = 0; i < noutputs; ++i) {
         TF_Tensor h = outputValues.get(TF_Tensor.class, i).withDeallocator();
-        outputTensors.add(Tensor.fromHandle(h));
+        outputTensors.add(Tensors.fromHandle(h));
       }
       try {
         return runMetadata != null ? RunMetadata.parseFrom(runMetadata.dataAsByteBuffer()) : null;
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 62c09926f64..16b93ba0590 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
@@ -15,10 +15,7 @@
 
 package org.tensorflow;
 
-import static org.tensorflow.internal.c_api.global.tensorflow.TF_Dim;
-import static org.tensorflow.internal.c_api.global.tensorflow.TF_NumDims;
 import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorByteSize;
-import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorType;
 
 import java.util.function.Consumer;
 import org.bytedeco.javacpp.PointerScope;
@@ -44,7 +41,7 @@
  * }
  * }</pre>
  */
-public final class Tensor<T extends TType> implements AutoCloseable {
+public interface Tensor<T extends TType> extends AutoCloseable {
 
   /**
    * Allocates a tensor of a given datatype and shape.
@@ -68,7 +65,7 @@ public final class Tensor<T extends TType> implements AutoCloseable {
    * @return an allocated but uninitialized tensor
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape) {
+  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape) {
     return of(dtype, shape, shape.size() * dtype.byteSize());
   }
 
@@ -91,20 +88,8 @@ public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape) {
    *                                  store the tensor data
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape, long size) {
-    // Minimum requirements for datatypes of variable length cannot be verified in a relevant way so
-    // we only validate them for fixed length datatypes
-    if (!dtype.isVariableLength() && shape.size() * dtype.byteSize() > size) {
-      throw new IllegalArgumentException("Tensor size is not large enough to contain all scalar values");
-    }
-    Tensor<T> t = new Tensor<>(dtype, shape);
-    TF_Tensor nativeHandle = allocate(t.dtype.nativeCode(), shape.asArray(), size);
-    try (PointerScope scope = new PointerScope()) {
-        scope.attach(nativeHandle);
-        t.tensorHandle = nativeHandle;
-        t.tensorScope = scope.extend();
-        return t;
-    }
+  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, long size) {
+    return Tensors.allocate(dtype, shape, size);
   }
 
   /**
@@ -131,8 +116,7 @@ public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape, lon
    * @return an allocated and initialized tensor
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape,
-      Consumer<T> dataInitializer) {
+  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, Consumer<T> dataInitializer) {
     return of(dtype, shape, shape.size() * dtype.byteSize(), dataInitializer);
   }
 
@@ -149,18 +133,17 @@ public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape,
    * @param dtype datatype of the tensor
    * @param shape shape of the tensor
    * @param size size, in bytes, of the tensor
-   * @param dataInitializer method receiving accessor to the allocated tensor data for initialization
+   * @param tensorInit method receiving accessor to the allocated tensor data for initialization
    * @return an allocated and initialized tensor
    * @see #of(DataType, Shape, long, Consumer)
    * @throws IllegalArgumentException if {@code size} is smaller than the minimum space required to
    *                                  store the tensor data
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape, long size,
-      Consumer<T> dataInitializer) {
-    Tensor<T> tensor = of(dtype, shape, size);
+  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, long size, Consumer<T> tensorInit) {
+    T tensor = of(dtype, shape, size);
     try {
-      dataInitializer.accept(tensor.data());
+      tensorInit.accept(tensor);
       return tensor;
     } catch (Throwable t) {
       tensor.close();
@@ -181,10 +164,10 @@ public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape, lon
    * @throws IllegalArgumentException if {@code rawData} is not large enough to contain the tensor data
    * @throws IllegalStateException if tensor failed to be allocated with the given parameters
    */
-  public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape, ByteDataBuffer rawData) {
-    Tensor<T> t = of(dtype, shape, rawData.size());
-    rawData.copyTo(TensorBuffers.toBytes(t.nativeHandle()), rawData.size());
-    return t;
+  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, ByteDataBuffer rawData) {
+    T tensor = of(dtype, shape, rawData.size());
+    rawData.copyTo(TensorBuffers.toBytes(tensor.nativeHandle()), rawData.size());
+    return tensor;
   }
 
   /**
@@ -196,12 +179,12 @@ public static <T extends TType> Tensor<T> of(DataType<T> dtype, Shape shape, Byt
    *     {@code U}.
    */
   @SuppressWarnings("unchecked")
-  public <U extends TType> Tensor<U> expect(DataType<U> dt) {
-    if (!dt.equals(this.dtype)) {
+  default <U extends TType & Tensor> U expect(DataType<U> dt) {
+    if (!dt.equals(dataType())) {
       throw new IllegalArgumentException(
-          "Cannot cast from tensor of " + dtype + " to tensor of " + dt);
+          "Cannot cast from tensor of " + dataType() + " to tensor of " + dt);
     }
-    return ((Tensor<U>) this);
+    return (U)this;
   }
 
   /**
@@ -213,22 +196,13 @@ public <U extends TType> Tensor<U> expect(DataType<U> dt) {
    * <p>The Tensor object is no longer usable after {@code close} returns.
    */
   @Override
-  public void close() {
-    tensorScope.close();
-  }
+  void close();
 
   /** Returns the {@link DataType} of elements stored in the Tensor. */
-  public DataType<T> dataType() {
-    return dtype;
-  }
+  DataType<T> dataType();
 
   /** Returns the size, in bytes, of the tensor data. */
-  public long numBytes() {
-    if (numBytes == null) {
-      numBytes = TF_TensorByteSize(tensorHandle);
-    }
-    return numBytes;
-  }
+  long numBytes();
 
   /**
    * Returns the <a href="https://www.tensorflow.org/resources/dims_types.html#shape">shape</a> of
@@ -236,9 +210,7 @@ public long numBytes() {
    *
    * @return shape of this tensor
    */
-  public Shape shape() {
-    return shape;
-  }
+  Shape shape();
 
   /**
    * Returns the data of this tensor.
@@ -272,13 +244,9 @@ public Shape shape() {
    * @throws IllegalStateException if the tensor has been closed
    * @see NdArray
    */
-  public T data() {
-    if (data == null) {
-      data = dtype.map(this);
-    } else {
-      nativeHandle(); // Checks that the tensor has not been released or will throw
-    }
-    return data;
+  default T data() {
+    nativeHandle(); // make sure native handle is still valid
+    return (T) this;
   }
 
   /**
@@ -291,95 +259,14 @@ public T data() {
    * @return the tensor raw data mapped to a read-only byte buffer
    * @throws IllegalStateException if the tensor has been closed
    */
-  public ByteDataBuffer rawData() {
-    return TensorBuffers.toBytes(nativeHandle(), true);
-  }
-
-  /** Returns a string describing the type and shape of the Tensor. */
-  @Override
-  public String toString() {
-    return String.format("%s tensor with shape %s", dtype.toString(), shape);
-  }
-
-  /**
-   * Create a Tensor object from a handle to the C TF_Tensor object.
-   *
-   * <p>Takes ownership of the handle.
-   */
-  static Tensor<?> fromHandle(TF_Tensor handle) {
-    Tensor<?> t = new Tensor<>(DataTypes.fromNativeCode(dtype(handle)), Shape.of(shape(handle)));
-    try (PointerScope scope = new PointerScope()) {
-        scope.attach(handle);
-        t.tensorHandle = handle;
-        t.tensorScope = scope.extend();
-    }
-    return t;
-  }
-
-  /**
-   * Create an eager Tensor object from a handle to the C TF_Tensor object.
-   *
-   * <p>Takes ownership of the handle.
-   */
-  static Tensor<?> fromHandle(TF_Tensor handle, EagerSession session) {
-    Tensor<?> t = fromHandle(handle);
-    session.attach(handle);
-    t.tensorScope.detach(handle);
-    return t;
-  }
+  ByteDataBuffer rawData();
 
   /**
    * @return native handle to this tensor
    * @throws IllegalStateException if tensor has been closed
    */
-  TF_Tensor nativeHandle() {
-    return requireHandle(tensorHandle);
-  }
-
-  private PointerScope tensorScope;
-  private TF_Tensor tensorHandle;
-
-  private static TF_Tensor requireHandle(TF_Tensor handle) {
-    if (handle == null || handle.isNull()) {
-      throw new IllegalStateException("close() was called on the Tensor");
-    }
-    return handle;
-  }
-
-  private static TF_Tensor allocate(int dtype, long[] shape, long byteSize) {
-    TF_Tensor t = TF_Tensor.allocateTensor(dtype, shape, byteSize);
-    if (t == null || t.isNull()) {
-      throw new IllegalStateException("unable to allocate memory for the Tensor");
-    }
-    return t;
-  }
-
-  private static int dtype(TF_Tensor handle) {
-    requireHandle(handle);
-    return TF_TensorType(handle);
-  }
-
-  private static long[] shape(TF_Tensor handle) {
-    requireHandle(handle);
-    int numDims = TF_NumDims(handle);
-    long[] dims = new long[numDims];
-    for (int i = 0; i < numDims; ++i) {
-      dims[i] = TF_Dim(handle, i);
-    }
-    return dims;
-  }
+  TF_Tensor nativeHandle();
+}
 
-  private final DataType<T> dtype;
-  private final Shape shape;
-  private T data = null;
-  private Long numBytes = null;
 
-  private Tensor(DataType<T> dtype, Shape shape) {
-    this.dtype = dtype;
-    this.shape = shape;
-  }
 
-  static {
-    TensorFlow.init();
-  }
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
new file mode 100644
index 00000000000..4ac2e92f714
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
@@ -0,0 +1,70 @@
+package org.tensorflow;
+
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_Dim;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_NumDims;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorType;
+
+import org.bytedeco.javacpp.PointerScope;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.types.family.TType;
+
+final class Tensors {
+
+  static <T extends TType> T allocate(DataType<T> dataType, Shape shape, long size) {
+    // Minimum requirements for datatypes of variable length cannot be verified in a relevant way so
+    // we only validate them for fixed length datatypes
+    if (!dataType.isVariableLength() && shape.size() * dataType.byteSize() > size) {
+      throw new IllegalArgumentException("Tensor size is not large enough to contain all scalar values");
+    }
+    TF_Tensor nativeHandle = allocate(dataType.nativeCode(), shape.asArray(), size);
+    try (PointerScope scope = new PointerScope()) {
+      scope.attach(nativeHandle);
+      return dataType.instantiateTensor(nativeHandle, shape);
+    }
+  }
+
+  /**
+   * Create a Tensor object from a handle to the C TF_Tensor object.
+   *
+   * <p>Takes ownership of the handle.
+   */
+  static Tensor<?> fromHandle(TF_Tensor handle) {
+    DataType<? extends Tensor> dataType = DataTypes.fromNativeCode(dtype(handle));
+    Shape shape = Shape.of(shape(handle));
+    try (PointerScope scope = new PointerScope()) {
+      scope.attach(handle);
+      return dataType.instantiateTensor(handle, shape);
+    }
+  }
+
+  private static TF_Tensor requireHandle(TF_Tensor handle) {
+    if (handle == null || handle.isNull()) {
+      throw new IllegalStateException("close() was called on the Tensor");
+    }
+    return handle;
+  }
+
+  private static TF_Tensor allocate(int dtype, long[] shape, long byteSize) {
+    TF_Tensor t = TF_Tensor.allocateTensor(dtype, shape, byteSize);
+    if (t == null || t.isNull()) {
+      throw new IllegalStateException("unable to allocate memory for the Tensor");
+    }
+    return t;
+  }
+
+  private static int dtype(TF_Tensor handle) {
+    requireHandle(handle);
+    return TF_TensorType(handle);
+  }
+
+  private static long[] shape(TF_Tensor handle) {
+    requireHandle(handle);
+    int numDims = TF_NumDims(handle);
+    long[] dims = new long[numDims];
+    for (int i = 0; i < numDims; ++i) {
+      dims[i] = TF_Dim(handle, i);
+    }
+    return dims;
+  }
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/StringTensorBuffer.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/ByteSequenceTensorBuffer.java
similarity index 91%
rename from tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/StringTensorBuffer.java
rename to tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/ByteSequenceTensorBuffer.java
index 24a8f54fedc..3fc160bc432 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/StringTensorBuffer.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/ByteSequenceTensorBuffer.java
@@ -50,7 +50,7 @@
  * <p>After its data has been initialized, the buffer is read-only as it is not possible to change
  * safely a value without reinitializing the whole data.
  */
-public class StringTensorBuffer extends AbstractDataBuffer<byte[]> {
+public class ByteSequenceTensorBuffer extends AbstractDataBuffer<byte[]> {
 
   /**
    * Computes how many bytes are required to store the given data in a string buffer.
@@ -66,7 +66,7 @@ public static <T> long computeSize(NdArray<T> data, Function<T, byte[]> getBytes
     // reserve space to store length and data of each values
     for (NdArray<T> scalar : data.scalars()) {
       byte[] elementBytes = getBytes.apply(scalar.getObject());
-      size += elementBytes.length + StringTensorBuffer.varintLength(elementBytes.length);
+      size += elementBytes.length + ByteSequenceTensorBuffer.varintLength(elementBytes.length);
     }
     return size;
   }
@@ -128,8 +128,8 @@ public boolean isReadOnly() {
 
   @Override
   public DataBuffer<byte[]> copyTo(DataBuffer<byte[]> dst, long size) {
-    if (size == size() && dst instanceof StringTensorBuffer) {
-      StringTensorBuffer tensorDst = (StringTensorBuffer) dst;
+    if (size == size() && dst instanceof ByteSequenceTensorBuffer) {
+      ByteSequenceTensorBuffer tensorDst = (ByteSequenceTensorBuffer) dst;
       if (offsets.size() != size || data.size() != size) {
         throw new IllegalArgumentException(
             "Cannot copy string tensor data to another tensor of a different size");
@@ -144,20 +144,20 @@ public DataBuffer<byte[]> copyTo(DataBuffer<byte[]> dst, long size) {
 
   @Override
   public DataBuffer<byte[]> offset(long index) {
-    return new StringTensorBuffer(offsets.offset(index), data);
+    return new ByteSequenceTensorBuffer(offsets.offset(index), data);
   }
 
   @Override
   public DataBuffer<byte[]> narrow(long size) {
-    return new StringTensorBuffer(offsets.narrow(size), data);
+    return new ByteSequenceTensorBuffer(offsets.narrow(size), data);
   }
 
   @Override
   public DataBuffer<byte[]> slice(long index, long size) {
-    return new StringTensorBuffer(offsets.slice(index, size), data);
+    return new ByteSequenceTensorBuffer(offsets.slice(index, size), data);
   }
 
-  StringTensorBuffer(LongDataBuffer offsets, ByteDataBuffer data) {
+  ByteSequenceTensorBuffer(LongDataBuffer offsets, ByteDataBuffer data) {
     this.offsets = offsets;
     this.data = data;
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorBuffers.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorBuffers.java
index f29396dd321..415c5ca35ef 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorBuffers.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorBuffers.java
@@ -156,7 +156,7 @@ public static BooleanDataBuffer toBooleans(TF_Tensor nativeTensor) {
    * @param nativeTensor native reference to the tensor
    * @return a string buffer
    */
-  public static StringTensorBuffer toStrings(TF_Tensor nativeTensor, long numElements) {
+  public static ByteSequenceTensorBuffer toStrings(TF_Tensor nativeTensor, long numElements) {
     Pointer tensorMemory = tensorMemory(nativeTensor);
     if (TensorRawDataBufferFactory.canBeUsed()) {
       return TensorRawDataBufferFactory.mapTensorToStrings(tensorMemory, numElements);
@@ -173,7 +173,7 @@ public static StringTensorBuffer toStrings(TF_Tensor nativeTensor, long numEleme
     dataBuffer.position((int)numElements * Long.BYTES);
     ByteDataBuffer data = DataBuffers.of(dataBuffer.slice());
 
-    return new StringTensorBuffer(offsets, data);
+    return new ByteSequenceTensorBuffer(offsets, data);
   }
 
   private static Pointer tensorMemory(TF_Tensor nativeTensor) {
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorRawDataBufferFactory.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorRawDataBufferFactory.java
index 1cfb1c9ab9a..dbaf31f1dcc 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorRawDataBufferFactory.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorRawDataBufferFactory.java
@@ -57,13 +57,13 @@ static BooleanDataBuffer mapTensorToBooleans(Pointer tensorMemory) {
     return mapNativeBooleans(tensorMemory.address(), tensorMemory.capacity(), false);
   }
 
-  static StringTensorBuffer mapTensorToStrings(Pointer tensorMemory, long numElements) {
+  static ByteSequenceTensorBuffer mapTensorToStrings(Pointer tensorMemory, long numElements) {
     long offsetByteSize = numElements * Long.BYTES;
     LongDataBuffer offsets = mapNativeLongs(tensorMemory.address(), offsetByteSize, false);
     ByteDataBuffer data = mapNativeBytes(
         tensorMemory.address() + offsetByteSize,
         tensorMemory.capacity() - offsetByteSize,
         false);
-    return new StringTensorBuffer(offsets, data);
+    return new ByteSequenceTensorBuffer(offsets, data);
   }
 }
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 6c214cc6819..c583bd8db0a 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
@@ -1004,9 +1004,9 @@ public static Constant<TUint8> tensorOf(Scope scope, Shape shape, ByteDataBuffer
    *     buffer
    */
   @Endpoint
-  public static <T extends TType> Constant<T> tensorOf(Scope scope, DataType<T> type, Shape shape,
+  public static <T extends TType & Tensor> Constant<T> tensorOf(Scope scope, DataType<T> type, Shape shape,
       ByteDataBuffer data) {
-    try (Tensor<T> value = Tensor.of(type, shape, data)) {
+    try (T value = Tensor.of(type, shape, data)) {
       return create(scope, value);
     }
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java
new file mode 100644
index 00000000000..627062a990f
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java
@@ -0,0 +1,126 @@
+package org.tensorflow.types;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.BooleanNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.impl.dense.BooleanDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
+import org.tensorflow.types.family.TType;
+
+public interface BooleanTensor<T extends BooleanTensor & TType> extends BooleanNdArray, Tensor<T> {
+
+  @Override
+  T setBoolean(boolean value, long... coordinates);
+
+  @Override
+  T set(NdArray<Boolean> src, long... coordinates);
+
+  @Override
+  T setObject(Boolean value, long... coordinates);
+
+  @Override
+  T copyTo(NdArray<Boolean> dst);
+
+  @Override
+  T read(DataBuffer<Boolean> dst);
+
+  @Override
+  T read(BooleanDataBuffer dst);
+
+  @Override
+  T write(DataBuffer<Boolean> src);
+
+  @Override
+  T write(BooleanDataBuffer src);
+}
+
+class BooleanTensorImpl<T extends BooleanTensor & TType> extends BooleanDenseNdArray implements BooleanTensor<T> {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public T setBoolean(boolean value, long... coordinates) {
+    return (T)super.setBoolean(value, coordinates);
+  }
+
+  @Override
+  public T setObject(Boolean value, long... coordinates) {
+    return (T)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public T set(NdArray<Boolean> src, long... coordinates) {
+    return (T)super.set(src, coordinates);
+  }
+
+  @Override
+  public T copyTo(NdArray<Boolean> dst) {
+    return (T)super.copyTo(dst);
+  }
+
+  @Override
+  public T read(DataBuffer<Boolean> dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T read(BooleanDataBuffer dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T write(DataBuffer<Boolean> src) {
+    return (T)super.write(src);
+  }
+
+  @Override
+  public T write(BooleanDataBuffer src) {
+    return (T)super.write(src);
+  }
+
+  BooleanTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, BooleanDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java
new file mode 100644
index 00000000000..48451e3781c
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java
@@ -0,0 +1,125 @@
+package org.tensorflow.types;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.ByteNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.impl.dense.ByteDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
+import org.tensorflow.types.family.TType;
+
+public interface ByteTensor<T extends ByteTensor & TType> extends ByteNdArray, Tensor<T> {
+
+  @Override
+  T setByte(byte value, long... coordinates);
+
+  @Override
+  T set(NdArray<Byte> src, long... coordinates);
+
+  @Override
+  T setObject(Byte value, long... coordinates);
+
+  @Override
+  T copyTo(NdArray<Byte> dst);
+
+  @Override
+  T read(DataBuffer<Byte> dst);
+
+  @Override
+  T read(ByteDataBuffer dst);
+
+  @Override
+  T write(DataBuffer<Byte> src);
+
+  @Override
+  T write(ByteDataBuffer src);
+}
+
+class ByteTensorImpl<T extends ByteTensor & TType> extends ByteDenseNdArray implements ByteTensor<T> {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public T setByte(byte value, long... coordinates) {
+    return (T)super.setByte(value, coordinates);
+  }
+
+  @Override
+  public T setObject(Byte value, long... coordinates) {
+    return (T)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public T set(NdArray<Byte> src, long... coordinates) {
+    return (T)super.set(src, coordinates);
+  }
+
+  @Override
+  public T copyTo(NdArray<Byte> dst) {
+    return (T)super.copyTo(dst);
+  }
+
+  @Override
+  public T read(DataBuffer<Byte> dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T read(ByteDataBuffer dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T write(DataBuffer<Byte> src) {
+    return (T)super.write(src);
+  }
+
+  @Override
+  public T write(ByteDataBuffer src) {
+    return (T)super.write(src);
+  }
+
+  ByteTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, ByteDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java
new file mode 100644
index 00000000000..83fb0fa1c0d
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java
@@ -0,0 +1,126 @@
+package org.tensorflow.types;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.DoubleNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
+import org.tensorflow.ndarray.impl.dense.DoubleDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
+import org.tensorflow.types.family.TType;
+
+public interface DoubleTensor<T extends DoubleTensor & TType> extends DoubleNdArray, Tensor<T> {
+
+  @Override
+  T setDouble(double value, long... coordinates);
+
+  @Override
+  T set(NdArray<Double> src, long... coordinates);
+
+  @Override
+  T setObject(Double value, long... coordinates);
+
+  @Override
+  T copyTo(NdArray<Double> dst);
+
+  @Override
+  T read(DataBuffer<Double> dst);
+
+  @Override
+  T read(DoubleDataBuffer dst);
+
+  @Override
+  T write(DataBuffer<Double> src);
+
+  @Override
+  T write(DoubleDataBuffer src);
+}
+
+class DoubleTensorImpl<T extends DoubleTensor & TType> extends DoubleDenseNdArray implements DoubleTensor<T> {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public T setDouble(double value, long... coordinates) {
+    return (T)super.setDouble(value, coordinates);
+  }
+
+  @Override
+  public T setObject(Double value, long... coordinates) {
+    return (T)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public T set(NdArray<Double> src, long... coordinates) {
+    return (T)super.set(src, coordinates);
+  }
+
+  @Override
+  public T copyTo(NdArray<Double> dst) {
+    return (T)super.copyTo(dst);
+  }
+
+  @Override
+  public T read(DataBuffer<Double> dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T read(DoubleDataBuffer dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T write(DataBuffer<Double> src) {
+    return (T)super.write(src);
+  }
+
+  @Override
+  public T write(DoubleDataBuffer src) {
+    return (T)super.write(src);
+  }
+
+  DoubleTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, DoubleDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java
new file mode 100644
index 00000000000..f819d073a4d
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java
@@ -0,0 +1,126 @@
+package org.tensorflow.types;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.FloatNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.FloatDataBuffer;
+import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
+import org.tensorflow.types.family.TType;
+
+public interface FloatTensor<T extends FloatTensor & TType> extends FloatNdArray, Tensor<T> {
+
+  @Override
+  T setFloat(float value, long... coordinates);
+
+  @Override
+  T set(NdArray<Float> src, long... coordinates);
+
+  @Override
+  T setObject(Float value, long... coordinates);
+
+  @Override
+  T copyTo(NdArray<Float> dst);
+
+  @Override
+  T read(DataBuffer<Float> dst);
+
+  @Override
+  T read(FloatDataBuffer dst);
+
+  @Override
+  T write(DataBuffer<Float> src);
+
+  @Override
+  T write(FloatDataBuffer src);
+}
+
+class FloatTensorImpl<T extends FloatTensor & TType> extends FloatDenseNdArray implements FloatTensor<T> {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public T setFloat(float value, long... coordinates) {
+    return (T)super.setFloat(value, coordinates);
+  }
+
+  @Override
+  public T setObject(Float value, long... coordinates) {
+    return (T)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public T set(NdArray<Float> src, long... coordinates) {
+    return (T)super.set(src, coordinates);
+  }
+
+  @Override
+  public T copyTo(NdArray<Float> dst) {
+    return (T)super.copyTo(dst);
+  }
+
+  @Override
+  public T read(DataBuffer<Float> dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T read(FloatDataBuffer dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T write(DataBuffer<Float> src) {
+    return (T)super.write(src);
+  }
+
+  @Override
+  public T write(FloatDataBuffer src) {
+    return (T)super.write(src);
+  }
+
+  FloatTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, FloatDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java
new file mode 100644
index 00000000000..041232e83d8
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java
@@ -0,0 +1,126 @@
+package org.tensorflow.types;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.IntNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.IntDataBuffer;
+import org.tensorflow.ndarray.impl.dense.IntDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
+import org.tensorflow.types.family.TType;
+
+public interface IntTensor<T extends IntTensor & TType> extends IntNdArray, Tensor<T> {
+
+  @Override
+  T setInt(int value, long... coordinates);
+
+  @Override
+  T set(NdArray<Integer> src, long... coordinates);
+
+  @Override
+  T setObject(Integer value, long... coordinates);
+
+  @Override
+  T copyTo(NdArray<Integer> dst);
+
+  @Override
+  T read(DataBuffer<Integer> dst);
+
+  @Override
+  T read(IntDataBuffer dst);
+
+  @Override
+  T write(DataBuffer<Integer> src);
+
+  @Override
+  T write(IntDataBuffer src);
+}
+
+class IntTensorImpl<T extends IntTensor & TType> extends IntDenseNdArray implements IntTensor<T> {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public T setInt(int value, long... coordinates) {
+    return (T)super.setInt(value, coordinates);
+  }
+
+  @Override
+  public T setObject(Integer value, long... coordinates) {
+    return (T)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public T set(NdArray<Integer> src, long... coordinates) {
+    return (T)super.set(src, coordinates);
+  }
+
+  @Override
+  public T copyTo(NdArray<Integer> dst) {
+    return (T)super.copyTo(dst);
+  }
+
+  @Override
+  public T read(DataBuffer<Integer> dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T read(IntDataBuffer dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T write(DataBuffer<Integer> src) {
+    return (T)super.write(src);
+  }
+
+  @Override
+  public T write(IntDataBuffer src) {
+    return (T)super.write(src);
+  }
+
+  IntTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, IntDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java
new file mode 100644
index 00000000000..b8965888f34
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java
@@ -0,0 +1,126 @@
+package org.tensorflow.types;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.LongNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.LongDataBuffer;
+import org.tensorflow.ndarray.impl.dense.LongDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
+import org.tensorflow.types.family.TType;
+
+public interface LongTensor<T extends LongTensor & TType> extends LongNdArray, Tensor<T> {
+
+  @Override
+  T setLong(long value, long... coordinates);
+
+  @Override
+  T set(NdArray<Long> src, long... coordinates);
+
+  @Override
+  T setObject(Long value, long... coordinates);
+
+  @Override
+  T copyTo(NdArray<Long> dst);
+
+  @Override
+  T read(DataBuffer<Long> dst);
+
+  @Override
+  T read(LongDataBuffer dst);
+
+  @Override
+  T write(DataBuffer<Long> src);
+
+  @Override
+  T write(LongDataBuffer src);
+}
+
+class LongTensorImpl<T extends LongTensor & TType> extends LongDenseNdArray implements LongTensor<T> {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public T setLong(long value, long... coordinates) {
+    return (T)super.setLong(value, coordinates);
+  }
+
+  @Override
+  public T setObject(Long value, long... coordinates) {
+    return (T)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public T set(NdArray<Long> src, long... coordinates) {
+    return (T)super.set(src, coordinates);
+  }
+
+  @Override
+  public T copyTo(NdArray<Long> dst) {
+    return (T)super.copyTo(dst);
+  }
+
+  @Override
+  public T read(DataBuffer<Long> dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T read(LongDataBuffer dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T write(DataBuffer<Long> src) {
+    return (T)super.write(src);
+  }
+
+  @Override
+  public T write(LongDataBuffer src) {
+    return (T)super.write(src);
+  }
+
+  LongTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, LongDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/RawTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/RawTensor.java
new file mode 100644
index 00000000000..872546c8ae0
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/RawTensor.java
@@ -0,0 +1,66 @@
+package org.tensorflow.types;
+
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorByteSize;
+
+import org.bytedeco.javacpp.PointerScope;
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.types.family.TType;
+
+class RawTensor<T extends TType> implements Tensor<T> {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    if (nativeHandle.isNull()) {
+      throw new IllegalStateException("Tensor has been already released");
+    }
+    return nativeHandle;
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return dtype;
+  }
+
+  @Override
+  public Shape shape() {
+    return shape;
+  }
+
+  @Override
+  public long numBytes() {
+    return TF_TensorByteSize(nativeHandle);
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return TensorBuffers.toBytes(nativeHandle, true);
+  }
+
+  @Override
+  public void close() {
+    tensorScope.close();
+  }
+
+  /** Returns a string describing the type and shape of the Tensor. */
+  @Override
+  public String toString() {
+    return String.format("%s tensor with shape %s", dataType().toString(), shape());
+  }
+
+  private final PointerScope tensorScope = new PointerScope();
+  private final TF_Tensor nativeHandle;
+  private final DataType<T> dtype;
+  private final Shape shape;
+
+  RawTensor(TF_Tensor nativeHandle, DataType<T> dtype, Shape shape) {
+    this.nativeHandle = nativeHandle;
+    this.dtype = dtype;
+    this.shape = shape;
+    this.tensorScope.attach(nativeHandle);
+  }
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/StringTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/StringTensor.java
new file mode 100644
index 00000000000..ca03e589360
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/StringTensor.java
@@ -0,0 +1,125 @@
+package org.tensorflow.types;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.buffer.ByteSequenceTensorBuffer;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.layout.DataLayout;
+import org.tensorflow.ndarray.impl.dense.DenseNdArray;
+import org.tensorflow.ndarray.index.Index;
+import org.tensorflow.types.family.TType;
+
+public interface StringTensor<T extends StringTensor & TType> extends NdArray<String>, Tensor<T> {
+
+  /**
+   * @return the tensor data as a n-dimensional array of raw byte sequences.
+   */
+  NdArray<byte[]> asBytes();
+
+  @Override
+  T set(NdArray<String> src, long... coordinates);
+
+  @Override
+  T setObject(String value, long... coordinates);
+
+  @Override
+  T copyTo(NdArray<String> dst);
+
+  @Override
+  T read(DataBuffer<String> dst);
+
+  @Override
+  T write(DataBuffer<String> src);
+}
+
+class StringTensorImpl<T extends StringTensor & TType> extends DenseNdArray<String> implements StringTensor<T> {
+
+  @Override
+  public NdArray<byte[]> asBytes() {
+    return NdArrays.wrap(shape(), rawBuffer);
+  }
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<T> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public T setObject(String value, long... coordinates) {
+    return (T)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public T set(NdArray<String> src, long... coordinates) {
+    return (T)super.set(src, coordinates);
+  }
+
+  @Override
+  public T copyTo(NdArray<String> dst) {
+    return (T)super.copyTo(dst);
+  }
+
+  @Override
+  public T read(DataBuffer<String> dst) {
+    return (T)super.read(dst);
+  }
+
+  @Override
+  public T write(DataBuffer<String> src) {
+    return (T)super.write(src);
+  }
+
+  protected ByteSequenceTensorBuffer rawBuffer() {
+    return rawBuffer;
+  }
+
+  StringTensorImpl(
+      TF_Tensor nativeHandle,
+      DataType<T> dataType,
+      Shape shape,
+      DataLayout<DataBuffer<byte[]>, String> layout,
+      ByteSequenceTensorBuffer buffer
+  ) {
+    super(layout.applyTo(buffer), shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+    this.rawBuffer = buffer;
+  }
+
+  private final RawTensor rawTensor;
+  private final ByteSequenceTensorBuffer rawBuffer;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
index 531bedc5e40..cc3aeba4282 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
@@ -23,14 +23,12 @@
 import org.tensorflow.exceptions.TensorFlowException;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.FloatDataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayouts;
-import org.tensorflow.ndarray.FloatNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
-import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TFloat;
 
 /**
  * Brain 16-bit float tensor type.
@@ -47,10 +45,10 @@
  * <p>Note that some CPUs support the bfloat16 format natively, which can result in faster computation
  * compared to {@link TFloat16} when GPUs are not used.
  */
-public interface TBfloat16 extends FloatNdArray, TNumber {
+public interface TBfloat16 extends FloatTensor<TBfloat16>, TFloat {
 
   /** Type metadata */
-  DataType<TBfloat16> DTYPE = DataType.create("BFLOAT16", 14, 2, TBfloat16Impl::mapTensor);
+  DataType<TBfloat16> DTYPE = DataType.create("BFLOAT16", 14, 2, TBfloat16Impl::new);
 
   /**
    * Allocates a new tensor for storing a single float value.
@@ -58,8 +56,8 @@ public interface TBfloat16 extends FloatNdArray, TNumber {
    * @param value float to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TBfloat16> scalarOf(float value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setFloat(value));
+  static TBfloat16 scalarOf(float value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
   }
 
   /**
@@ -68,11 +66,11 @@ static Tensor<TBfloat16> scalarOf(float value) {
    * @param values floats to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TBfloat16> vectorOf(float... values) {
+  static TBfloat16 vectorOf(float... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -83,7 +81,7 @@ static Tensor<TBfloat16> vectorOf(float... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TBfloat16> tensorOf(NdArray<Float> src) {
+  static TBfloat16 tensorOf(NdArray<Float> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -93,7 +91,7 @@ static Tensor<TBfloat16> tensorOf(NdArray<Float> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TBfloat16> tensorOf(Shape shape) {
+  static TBfloat16 tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -104,34 +102,34 @@ static Tensor<TBfloat16> tensorOf(Shape shape) {
    * @param data buffer of floats to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TBfloat16> tensorOf(Shape shape, FloatDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+  static TBfloat16 tensorOf(Shape shape, FloatDataBuffer data) {
+    return Tensor.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
-  static Tensor<TBfloat16> tensorOf(Shape shape, Consumer<TBfloat16> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TBfloat16 tensorOf(Shape shape, Consumer<TBfloat16> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TBfloat16}
  */
-class TBfloat16Impl extends FloatDenseNdArray implements TBfloat16 {
+class TBfloat16Impl extends FloatTensorImpl<TBfloat16> implements TBfloat16 {
 
-  static TBfloat16 mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TBfloat16Impl(DataLayouts.BFLOAT16.applyTo(TensorBuffers.toShorts(nativeTensor)), shape);
+  TBfloat16Impl(TF_Tensor nativeTensorHandle, Shape shape) {
+    super(nativeTensorHandle, DTYPE, shape, mapMemory(nativeTensorHandle));
   }
 
-  private TBfloat16Impl(FloatDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  private static FloatDataBuffer mapMemory(TF_Tensor nativeTensorHandle) {
+    return DataLayouts.BFLOAT16.applyTo(TensorBuffers.toShorts(nativeTensorHandle));
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
index 835d0a1be31..7566e0a5099 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
@@ -23,13 +23,11 @@
 import org.tensorflow.exceptions.TensorFlowException;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.buffer.layout.DataLayouts;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
-import org.tensorflow.ndarray.BooleanNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.BooleanDenseNdArray;
+import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
+import org.tensorflow.ndarray.buffer.layout.DataLayouts;
 import org.tensorflow.types.family.TType;
 
 /**
@@ -40,10 +38,10 @@
  * {@link DataLayouts#BOOL BOOL} layout, which may impact I/O
  * performances.
  */
-public interface TBool extends BooleanNdArray, TType {
+public interface TBool extends BooleanTensor<TBool>, TType {
 
   /** Type metadata */
-  DataType<TBool> DTYPE = DataType.create("BOOL", 10, 1, TBoolImpl::mapTensor);
+  DataType<TBool> DTYPE = DataType.create("BOOL", 10, 1, TBoolImpl::new);
 
   /**
    * Allocates a new tensor for storing a single boolean value.
@@ -51,8 +49,8 @@ public interface TBool extends BooleanNdArray, TType {
    * @param value boolean to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TBool> scalarOf(boolean value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setBoolean(value));
+  static TBool scalarOf(boolean value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setBoolean(value));
   }
 
   /**
@@ -61,11 +59,11 @@ static Tensor<TBool> scalarOf(boolean value) {
    * @param values booleans to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TBool> vectorOf(boolean... values) {
+  static TBool vectorOf(boolean... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -76,7 +74,7 @@ static Tensor<TBool> vectorOf(boolean... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TBool> tensorOf(NdArray<Boolean> src) {
+  static TBool tensorOf(NdArray<Boolean> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -86,7 +84,7 @@ static Tensor<TBool> tensorOf(NdArray<Boolean> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TBool> tensorOf(Shape shape) {
+  static TBool tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -97,7 +95,7 @@ static Tensor<TBool> tensorOf(Shape shape) {
    * @param data buffer of booleans to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TBool> tensorOf(Shape shape, BooleanDataBuffer data) {
+  static TBool tensorOf(Shape shape, BooleanDataBuffer data) {
     return Tensor.of(DTYPE, shape, d -> d.write(data));
   }
 
@@ -105,25 +103,21 @@ static Tensor<TBool> tensorOf(Shape shape, BooleanDataBuffer data) {
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
-  static Tensor<TBool> tensorOf(Shape shape, Consumer<TBool> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TBool tensorOf(Shape shape, Consumer<TBool> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TBool}
  */
-class TBoolImpl extends BooleanDenseNdArray implements TBool {
-
-  static TBool mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TBoolImpl(TensorBuffers.toBooleans(nativeTensor), shape);
-  }
+class TBoolImpl extends BooleanTensorImpl<TBool> implements TBool {
 
-  private TBoolImpl(BooleanDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  TBoolImpl(TF_Tensor nativeTensor, Shape shape) {
+    super(nativeTensor, DTYPE, shape, TensorBuffers.toBooleans(nativeTensor));
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
index 3f0deb00d0f..114bf6d902b 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
@@ -23,14 +23,12 @@
 import org.tensorflow.exceptions.TensorFlowException;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.FloatDataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayouts;
-import org.tensorflow.ndarray.FloatNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
-import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TFloat;
 
 /**
  * IEEE-754 half-precision 16-bit float tensor type.
@@ -44,10 +42,10 @@
  * CPUs do not support this format natively. For CPU computation on 16-bit floats, the {@link TBfloat16}
  * tensor type might be a better option.
  */
-public interface TFloat16 extends FloatNdArray, TNumber {
+public interface TFloat16 extends FloatTensor<TFloat16>, TFloat {
 
   /** Type metadata */
-  DataType<TFloat16> DTYPE = DataType.create("FLOAT16", 19, 2, TFloat16Impl::mapTensor);
+  DataType<TFloat16> DTYPE = DataType.create("FLOAT16", 19, 2, TFloat16Impl::new);
 
   /**
    * Allocates a new tensor for storing a single float value.
@@ -55,8 +53,8 @@ public interface TFloat16 extends FloatNdArray, TNumber {
    * @param value float to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat16> scalarOf(float value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setFloat(value));
+  static TFloat16 scalarOf(float value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
   }
 
   /**
@@ -65,11 +63,11 @@ static Tensor<TFloat16> scalarOf(float value) {
    * @param values floats to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat16> vectorOf(float... values) {
+  static TFloat16 vectorOf(float... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -80,7 +78,7 @@ static Tensor<TFloat16> vectorOf(float... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat16> tensorOf(NdArray<Float> src) {
+  static TFloat16 tensorOf(NdArray<Float> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -90,7 +88,7 @@ static Tensor<TFloat16> tensorOf(NdArray<Float> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TFloat16> tensorOf(Shape shape) {
+  static TFloat16 tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -101,34 +99,34 @@ static Tensor<TFloat16> tensorOf(Shape shape) {
    * @param data buffer of floats to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TFloat16> tensorOf(Shape shape, FloatDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+  static TFloat16 tensorOf(Shape shape, FloatDataBuffer data) {
+    return Tensor.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
-  static Tensor<TFloat16> tensorOf(Shape shape, Consumer<TFloat16> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TFloat16 tensorOf(Shape shape, Consumer<TFloat16> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TFloat16}
  */
-class TFloat16Impl extends FloatDenseNdArray implements TFloat16 {
+class TFloat16Impl extends FloatTensorImpl<TFloat16> implements TFloat16 {
 
-  static TFloat16 mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TFloat16Impl(DataLayouts.FLOAT16.applyTo(TensorBuffers.toShorts(nativeTensor)), shape);
+  TFloat16Impl(TF_Tensor nativeTensor, Shape shape) {
+    super(nativeTensor, DTYPE, shape, mapMemory(nativeTensor));
   }
 
-  private TFloat16Impl(FloatDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  private static FloatDataBuffer mapMemory(TF_Tensor nativeTensor) {
+    return DataLayouts.FLOAT16.applyTo(TensorBuffers.toShorts(nativeTensor));
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
index 4b06ad2d57e..a4309a7db74 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
@@ -23,21 +23,19 @@
 import org.tensorflow.exceptions.TensorFlowException;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.FloatDataBuffer;
-import org.tensorflow.ndarray.FloatNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
-import org.tensorflow.types.family.TNumber;
+import org.tensorflow.ndarray.buffer.FloatDataBuffer;
+import org.tensorflow.types.family.TFloat;
 
 /**
  * IEEE-754 single-precision 32-bit float tensor type.
  */
-public interface TFloat32 extends FloatNdArray, TNumber {
+public interface TFloat32 extends FloatTensor<TFloat32>, TFloat {
 
   /** Type metadata */
-  DataType<TFloat32> DTYPE = DataType.create("FLOAT", 1, 4, TFloat32Impl::mapTensor);
+  DataType<TFloat32> DTYPE = DataType.create("FLOAT", 1, 4, TFloat32Impl::new);
 
   /**
    * Allocates a new tensor for storing a single float value.
@@ -45,8 +43,8 @@ public interface TFloat32 extends FloatNdArray, TNumber {
    * @param value float to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat32> scalarOf(float value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setFloat(value));
+  static TFloat32 scalarOf(float value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
   }
 
   /**
@@ -55,11 +53,11 @@ static Tensor<TFloat32> scalarOf(float value) {
    * @param values floats to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat32> vectorOf(float... values) {
+  static TFloat32 vectorOf(float... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -70,7 +68,7 @@ static Tensor<TFloat32> vectorOf(float... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat32> tensorOf(NdArray<Float> src) {
+  static TFloat32 tensorOf(NdArray<Float> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -80,7 +78,7 @@ static Tensor<TFloat32> tensorOf(NdArray<Float> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TFloat32> tensorOf(Shape shape) {
+  static TFloat32 tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -91,34 +89,30 @@ static Tensor<TFloat32> tensorOf(Shape shape) {
    * @param data buffer of floats to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TFloat32> tensorOf(Shape shape, FloatDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+  static TFloat32 tensorOf(Shape shape, FloatDataBuffer data) {
+    return Tensor.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
-  static Tensor<TFloat32> tensorOf(Shape shape, Consumer<TFloat32> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TFloat32 tensorOf(Shape shape, Consumer<TFloat32> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TFloat32}
  */
-class TFloat32Impl extends FloatDenseNdArray implements TFloat32 {
-
-  static TFloat32 mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TFloat32Impl(TensorBuffers.toFloats(nativeTensor), shape);
-  }
+class TFloat32Impl extends FloatTensorImpl<TFloat32> implements TFloat32 {
 
-  private TFloat32Impl(FloatDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  TFloat32Impl(TF_Tensor nativeTensor, Shape shape) {
+    super(nativeTensor, DTYPE, shape, TensorBuffers.toFloats(nativeTensor));
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
index 0b2109ac374..f909aa6f5ee 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
@@ -23,21 +23,19 @@
 import org.tensorflow.exceptions.TensorFlowException;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
-import org.tensorflow.ndarray.DoubleNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.DoubleDenseNdArray;
-import org.tensorflow.types.family.TNumber;
+import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
+import org.tensorflow.types.family.TFloat;
 
 /**
  * IEEE-754 double-precision 64-bit float tensor type.
  */
-public interface TFloat64 extends DoubleNdArray, TNumber {
+public interface TFloat64 extends DoubleTensor<TFloat64>, TFloat {
 
   /** Type metadata */
-  DataType<TFloat64> DTYPE = DataType.create("DOUBLE", 2, 8, TFloat64Impl::mapTensor);
+  DataType<TFloat64> DTYPE = DataType.create("DOUBLE", 2, 8, TFloat64Impl::new);
 
   /**
    * Allocates a new tensor for storing a single double value.
@@ -45,8 +43,8 @@ public interface TFloat64 extends DoubleNdArray, TNumber {
    * @param value double to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat64> scalarOf(double value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setDouble(value));
+  static TFloat64 scalarOf(double value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setDouble(value));
   }
 
   /**
@@ -55,11 +53,11 @@ static Tensor<TFloat64> scalarOf(double value) {
    * @param values doubles to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat64> vectorOf(double... values) {
+  static TFloat64 vectorOf(double... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -70,7 +68,7 @@ static Tensor<TFloat64> vectorOf(double... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TFloat64> tensorOf(NdArray<Double> src) {
+  static TFloat64 tensorOf(NdArray<Double> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -80,7 +78,7 @@ static Tensor<TFloat64> tensorOf(NdArray<Double> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TFloat64> tensorOf(Shape shape) {
+  static TFloat64 tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -91,33 +89,29 @@ static Tensor<TFloat64> tensorOf(Shape shape) {
    * @param data buffer of doubles to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TFloat64> tensorOf(Shape shape, DoubleDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+  static TFloat64 tensorOf(Shape shape, DoubleDataBuffer data) {
+    return Tensor.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
-  static Tensor<TFloat64> tensorOf(Shape shape, Consumer<TFloat64> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TFloat64 tensorOf(Shape shape, Consumer<TFloat64> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TFloat64}
  */
-class TFloat64Impl extends DoubleDenseNdArray implements TFloat64 {
-
-  static TFloat64 mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TFloat64Impl(TensorBuffers.toDoubles(nativeTensor), shape);
-  }
+class TFloat64Impl extends DoubleTensorImpl<TFloat64> implements TFloat64 {
 
-  private TFloat64Impl(DoubleDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  TFloat64Impl(TF_Tensor nativeTensor, Shape shape) {
+    super(nativeTensor, DTYPE, shape, TensorBuffers.toDoubles(nativeTensor));
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
index ac0dbec1d42..312fb082eda 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
@@ -22,21 +22,19 @@
 import org.tensorflow.Tensor;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.IntDataBuffer;
-import org.tensorflow.ndarray.IntNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.IntDenseNdArray;
+import org.tensorflow.ndarray.buffer.IntDataBuffer;
 import org.tensorflow.types.family.TNumber;
 
 /**
  * 32-bit signed integer tensor type.
  */
-public interface TInt32 extends IntNdArray, TNumber {
+public interface TInt32 extends IntTensor<TInt32>, TNumber {
 
   /** Type metadata */
-  DataType<TInt32> DTYPE = DataType.create("INT32", 3, 4, TInt32Impl::mapTensor);
+  DataType<TInt32> DTYPE = DataType.create("INT32", 3, 4, TInt32Impl::new);
 
   /**
    * Allocates a new tensor for storing a single int value.
@@ -44,8 +42,8 @@ public interface TInt32 extends IntNdArray, TNumber {
    * @param value int to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TInt32> scalarOf(int value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setInt(value));
+  static TInt32 scalarOf(int value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setInt(value));
   }
 
   /**
@@ -55,11 +53,11 @@ static Tensor<TInt32> scalarOf(int value) {
    * @return the new tensor
    * @throws IllegalArgumentException if no values are provided
    */
-  static Tensor<TInt32> vectorOf(int... values) {
+  static TInt32 vectorOf(int... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -70,7 +68,7 @@ static Tensor<TInt32> vectorOf(int... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TInt32> tensorOf(NdArray<Integer> src) {
+  static TInt32 tensorOf(NdArray<Integer> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -80,7 +78,7 @@ static Tensor<TInt32> tensorOf(NdArray<Integer> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TInt32> tensorOf(Shape shape) {
+  static TInt32 tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -91,32 +89,28 @@ static Tensor<TInt32> tensorOf(Shape shape) {
    * @param data buffer of ints to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TInt32> tensorOf(Shape shape, IntDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+  static TInt32 tensorOf(Shape shape, IntDataBuffer data) {
+    return Tensor.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    */
-  static Tensor<TInt32> tensorOf(Shape shape, Consumer<TInt32> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TInt32 tensorOf(Shape shape, Consumer<TInt32> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TInt32}
  */
-class TInt32Impl extends IntDenseNdArray implements TInt32 {
-
-  static TInt32 mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TInt32Impl(TensorBuffers.toInts(nativeTensor), shape);
-  }
+class TInt32Impl extends IntTensorImpl<TInt32> implements TInt32 {
 
-  private TInt32Impl(IntDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  TInt32Impl(TF_Tensor nativeTensor, Shape shape) {
+    super(nativeTensor, DTYPE, shape, TensorBuffers.toInts(nativeTensor));
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
index bbe05f9b1ff..b90cd26264f 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
@@ -23,21 +23,19 @@
 import org.tensorflow.exceptions.TensorFlowException;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.LongDataBuffer;
-import org.tensorflow.ndarray.LongNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.LongDenseNdArray;
+import org.tensorflow.ndarray.buffer.LongDataBuffer;
 import org.tensorflow.types.family.TNumber;
 
 /**
  * 64-bit signed integer tensor type.
  */
-public interface TInt64 extends LongNdArray, TNumber {
+public interface TInt64 extends LongTensor<TInt64>, TNumber {
 
   /** Type metadata */
-  DataType<TInt64> DTYPE = DataType.create("INT64", 9, 8, TInt64Impl::mapTensor);
+  DataType<TInt64> DTYPE = DataType.create("INT64", 9, 8, TInt64Impl::new);
 
   /**
    * Allocates a new tensor for storing a single long value.
@@ -45,8 +43,8 @@ public interface TInt64 extends LongNdArray, TNumber {
    * @param value long to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TInt64> scalarOf(long value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setLong(value));
+  static TInt64 scalarOf(long value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setLong(value));
   }
 
   /**
@@ -55,11 +53,11 @@ static Tensor<TInt64> scalarOf(long value) {
    * @param values longs to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TInt64> vectorOf(long... values) {
+  static TInt64 vectorOf(long... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -70,7 +68,7 @@ static Tensor<TInt64> vectorOf(long... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TInt64> tensorOf(NdArray<Long> src) {
+  static TInt64 tensorOf(NdArray<Long> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -80,7 +78,7 @@ static Tensor<TInt64> tensorOf(NdArray<Long> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TInt64> tensorOf(Shape shape) {
+  static TInt64 tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -91,33 +89,29 @@ static Tensor<TInt64> tensorOf(Shape shape) {
    * @param data buffer of longs to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TInt64> tensorOf(Shape shape, LongDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+  static TInt64 tensorOf(Shape shape, LongDataBuffer data) {
+    return Tensor.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
-  static Tensor<TInt64> tensorOf(Shape shape, Consumer<TInt64> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TInt64 tensorOf(Shape shape, Consumer<TInt64> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TInt64}
  */
-class TInt64Impl extends LongDenseNdArray implements TInt64 {
-
-  static TInt64 mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TInt64Impl(TensorBuffers.toLongs(nativeTensor), shape);
-  }
+class TInt64Impl extends LongTensorImpl<TInt64> implements TInt64 {
 
-  private TInt64Impl(LongDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  TInt64Impl(TF_Tensor nativeTensor, Shape shape) {
+    super(nativeTensor, DTYPE, shape, TensorBuffers.toLongs(nativeTensor));
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
index 90ae4ef9cb8..ccf8818b048 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
@@ -22,16 +22,15 @@
 import java.util.function.Function;
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.buffer.StringTensorBuffer;
+import org.tensorflow.internal.buffer.ByteSequenceTensorBuffer;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayout;
 import org.tensorflow.ndarray.buffer.layout.DataLayouts;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.NdArrays;
-import org.tensorflow.ndarray.impl.dense.DenseNdArray;
 import org.tensorflow.types.family.TType;
 
 /**
@@ -43,12 +42,12 @@
  * its values initially, so TensorFlow can compute and allocate the right amount of memory. Then
  * the data in the tensor is initialized once and cannot be modified afterwards.
  */
-public interface TString extends NdArray<String>, TType {
+public interface TString extends StringTensor<TString>, TType {
 
   /**
    * Type metadata
    */
-  DataType<TString> DTYPE = DataType.create("STRING", 7, -1, TStringImpl::mapTensor);
+  DataType<TString> DTYPE = DataType.create("STRING", 7, -1, TStringImpl::new);
 
   /**
    * Allocates a new tensor for storing a string scalar.
@@ -58,7 +57,7 @@ public interface TString extends NdArray<String>, TType {
    * @param value scalar value to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TString> scalarOf(String value) {
+  static TString scalarOf(String value) {
     return tensorOf(NdArrays.scalarOfObject(value));
   }
 
@@ -70,7 +69,7 @@ static Tensor<TString> scalarOf(String value) {
    * @param values values to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TString> vectorOf(String... values) {
+  static TString vectorOf(String... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
@@ -86,7 +85,7 @@ static Tensor<TString> vectorOf(String... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TString> tensorOf(NdArray<String> src) {
+  static TString tensorOf(NdArray<String> src) {
     return tensorOf(StandardCharsets.UTF_8, src);
   }
 
@@ -111,7 +110,7 @@ static Tensor<TString> tensorOf(NdArray<String> src) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TString> tensorOf(Charset charset, NdArray<String> src) {
+  static TString tensorOf(Charset charset, NdArray<String> src) {
     return TStringImpl.createTensor(src, s -> s.getBytes(charset));
   }
 
@@ -125,7 +124,7 @@ static Tensor<TString> tensorOf(Charset charset, NdArray<String> src) {
    * @param data buffer of strings to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TString> tensorOf(Shape shape, DataBuffer<String> data) {
+  static TString tensorOf(Shape shape, DataBuffer<String> data) {
     return tensorOf(NdArrays.wrap(shape, data));
   }
 
@@ -152,7 +151,7 @@ static Tensor<TString> tensorOf(Shape shape, DataBuffer<String> data) {
    * @param data buffer of strings to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TString> tensorOf(Charset charset, Shape shape, DataBuffer<String> data) {
+  static TString tensorOf(Charset charset, Shape shape, DataBuffer<String> data) {
     return tensorOf(charset, NdArrays.wrap(shape, data));
   }
 
@@ -171,7 +170,7 @@ static Tensor<TString> tensorOf(Charset charset, Shape shape, DataBuffer<String>
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TString> tensorOfBytes(NdArray<byte[]> src) {
+  static TString tensorOfBytes(NdArray<byte[]> src) {
     return TStringImpl.createTensor(src, Function.identity());
   }
 
@@ -190,7 +189,7 @@ static Tensor<TString> tensorOfBytes(NdArray<byte[]> src) {
    * @param data the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TString> tensorOfBytes(Shape shape, DataBuffer<byte[]> data) {
+  static TString tensorOfBytes(Shape shape, DataBuffer<byte[]> data) {
     return tensorOfBytes(NdArrays.wrap(shape, data));
   }
 
@@ -211,47 +210,33 @@ static Tensor<TString> tensorOfBytes(Shape shape, DataBuffer<byte[]> data) {
    * @return string tensor data using this charset
    */
   TString using(Charset charset);
-
-  /**
-   * @return the tensor data as a n-dimensional array of raw byte sequences.
-   */
-  NdArray<byte[]> asBytes();
 }
 
 /**
  * Hidden implementation of a {@code TString}
  */
-class TStringImpl extends DenseNdArray<String> implements TString {
+class TStringImpl extends StringTensorImpl<TString> implements TString {
 
   @Override
   public TString using(Charset charset) {
-    return new TStringImpl(tensorBuffer, DataLayouts.ofStrings(charset), shape());
+    return new TStringImpl(nativeHandle(), shape(), DataLayouts.ofStrings(charset), rawBuffer());
   }
 
-  @Override
-  public NdArray<byte[]> asBytes() {
-    return NdArrays.wrap(shape(), tensorBuffer);
-  }
-
-  static <T> Tensor<TString> createTensor(NdArray<T> src, Function<T, byte[]> getBytes) {
-    long size = StringTensorBuffer.computeSize(src, getBytes);
-    return Tensor.of(TString.DTYPE, src.shape(), size, data ->
-        ((TStringImpl)data).tensorBuffer.init(src, getBytes)
+  static <T> TString createTensor(NdArray<T> src, Function<T, byte[]> getBytes) {
+    long size = ByteSequenceTensorBuffer.computeSize(src, getBytes);
+    return Tensor.of(TString.DTYPE, src.shape(), size, t ->
+        ((TStringImpl)t).rawBuffer().init(src, getBytes)
     );
   }
 
-  static TString mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    StringTensorBuffer buffer = TensorBuffers.toStrings(nativeTensor, shape.size());
-    return new TStringImpl(buffer, UTF_8_LAYOUT, shape);
+  TStringImpl(TF_Tensor nativeTensor, Shape shape) {
+    this(nativeTensor, shape, UTF_8_LAYOUT, TensorBuffers.toStrings(nativeTensor, shape.size()));
   }
 
-  private static DataLayout<DataBuffer<byte[]>, String> UTF_8_LAYOUT = DataLayouts.ofStrings(StandardCharsets.UTF_8);
-
-  private final StringTensorBuffer tensorBuffer;
+  private static final DataLayout<DataBuffer<byte[]>, String> UTF_8_LAYOUT = DataLayouts.ofStrings(StandardCharsets.UTF_8);
 
-  private TStringImpl(StringTensorBuffer buffer, DataLayout<DataBuffer<byte[]>, String> layout, Shape shape) {
-    super(layout.applyTo(buffer), shape);
-    tensorBuffer = buffer;
+  private TStringImpl(TF_Tensor nativeTensor, Shape shape, DataLayout<DataBuffer<byte[]>, String> layout, ByteSequenceTensorBuffer rawBuffer) {
+    super(nativeTensor, TString.DTYPE, shape, layout, rawBuffer);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
index f55959194e5..d104d0e409a 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
@@ -23,21 +23,19 @@
 import org.tensorflow.exceptions.TensorFlowException;
 import org.tensorflow.internal.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.ByteNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
-import org.tensorflow.ndarray.impl.dense.ByteDenseNdArray;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.types.family.TNumber;
 
 /**
  * 8-bit unsigned integer tensor type.
  */
-public interface TUint8 extends ByteNdArray, TNumber {
+public interface TUint8 extends ByteTensor<TUint8>, TNumber {
 
   /** Type metadata */
-  DataType<TUint8> DTYPE = DataType.create("UINT8", 4, 1, TUint8Impl::mapTensor);
+  DataType<TUint8> DTYPE = DataType.create("UINT8", 4, 1, TUint8Impl::new);
 
   /**
    * Allocates a new tensor for storing a single byte value.
@@ -45,8 +43,8 @@ public interface TUint8 extends ByteNdArray, TNumber {
    * @param value byte to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TUint8> scalarOf(byte value) {
-    return Tensor.of(DTYPE, Shape.scalar(), data -> data.setByte(value));
+  static TUint8 scalarOf(byte value) {
+    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setByte(value));
   }
 
   /**
@@ -55,11 +53,11 @@ static Tensor<TUint8> scalarOf(byte value) {
    * @param values bytes to store in the new tensor
    * @return the new tensor
    */
-  static Tensor<TUint8> vectorOf(byte... values) {
+  static TUint8 vectorOf(byte... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), data -> StdArrays.copyTo(values, data));
+    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -70,7 +68,7 @@ static Tensor<TUint8> vectorOf(byte... values) {
    * @param src the source array giving the shape and data to the new tensor
    * @return the new tensor
    */
-  static Tensor<TUint8> tensorOf(NdArray<Byte> src) {
+  static TUint8 tensorOf(NdArray<Byte> src) {
     return Tensor.of(DTYPE, src.shape(), src::copyTo);
   }
 
@@ -80,7 +78,7 @@ static Tensor<TUint8> tensorOf(NdArray<Byte> src) {
    * @param shape shape of the tensor to allocate
    * @return the new tensor
    */
-  static Tensor<TUint8> tensorOf(Shape shape) {
+  static TUint8 tensorOf(Shape shape) {
     return Tensor.of(DTYPE, shape);
   }
 
@@ -91,7 +89,7 @@ static Tensor<TUint8> tensorOf(Shape shape) {
    * @param data buffer of bytes to initialize the tensor with
    * @return the new tensor
    */
-  static Tensor<TUint8> tensorOf(Shape shape, ByteDataBuffer data) {
+  static TUint8 tensorOf(Shape shape, ByteDataBuffer data) {
     return Tensor.of(DTYPE, shape, d -> d.write(data));
   }
 
@@ -99,25 +97,21 @@ static Tensor<TUint8> tensorOf(Shape shape, ByteDataBuffer data) {
    * Allocates a new tensor of the given shape and initialize its data.
    *
    * @param shape shape of the tensor to allocate
-   * @param dataInit tensor data initializer
+   * @param tensorInit tensor data initializer
    * @return the new tensor
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
-  static Tensor<TUint8> tensorOf(Shape shape, Consumer<TUint8> dataInit) {
-    return Tensor.of(DTYPE, shape, dataInit);
+  static TUint8 tensorOf(Shape shape, Consumer<TUint8> tensorInit) {
+    return Tensor.of(DTYPE, shape, tensorInit);
   }
 }
 
 /**
  * Hidden implementation of a {@code TUint8}
  */
-class TUint8Impl extends ByteDenseNdArray implements TUint8 {
-
-  static TUint8 mapTensor(TF_Tensor nativeTensor, Shape shape) {
-    return new TUint8Impl(TensorBuffers.toBytes(nativeTensor), shape);
-  }
+class TUint8Impl extends ByteTensorImpl<TUint8> implements TUint8 {
 
-  private TUint8Impl(ByteDataBuffer buffer, Shape shape) {
-    super(buffer, shape);
+  TUint8Impl(TF_Tensor nativeTensor, Shape shape) {
+    super(nativeTensor, DTYPE, shape, TensorBuffers.toBytes(nativeTensor));
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.java
new file mode 100644
index 00000000000..297efc1f560
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.java
@@ -0,0 +1,5 @@
+package org.tensorflow.types.family;
+
+public interface TFloat extends TNumber {
+
+}
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 01ef11efedd..6c60480dfda 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
@@ -504,7 +504,7 @@ public void fromHandle() {
     // close() on both Tensors.
     final FloatNdArray matrix = StdArrays.ndCopyOf(new float[][]{{1, 2, 3}, {4, 5, 6}});
     try (Tensor<TFloat32> src = TFloat32.tensorOf(matrix)) {
-      Tensor<TFloat32> cpy = Tensor.fromHandle(src.nativeHandle()).expect(TFloat32.DTYPE);
+      Tensor<TFloat32> cpy = Tensors.fromHandle(src.nativeHandle()).expect(TFloat32.DTYPE);
       assertEquals(src.dataType(), cpy.dataType());
       assertEquals(src.shape().numDimensions(), cpy.shape().numDimensions());
       assertEquals(src.shape(), cpy.shape());

From 202a2228758f1fb4f5e466d2f375f952a93b58c2 Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Thu, 30 Jul 2020 12:58:04 -0400
Subject: [PATCH 2/4] Extends  from

---
 .../src/main/java/org/tensorflow/types/family/TFloat.java    | 5 -----
 .../src/main/java/org/tensorflow/types/family/TFloating.java | 5 +++++
 2 files changed, 5 insertions(+), 5 deletions(-)
 delete mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java

diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.java
deleted file mode 100644
index 297efc1f560..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloat.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package org.tensorflow.types.family;
-
-public interface TFloat extends TNumber {
-
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
new file mode 100644
index 00000000000..b8937c64630
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
@@ -0,0 +1,5 @@
+package org.tensorflow.types.family;
+
+public interface TFloat {
+
+}

From 93d1f641e3f78341dc27daf9aa78e9e5a0a7836a Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Sun, 2 Aug 2020 09:37:24 -0400
Subject: [PATCH 3/4] Convert TType generic parameters to Tensor

---
 .../src/bazel/op_generator/op_generator.cc    |   9 +-
 .../src/bazel/op_generator/op_specs.cc        |   4 +-
 .../src/bazel/op_generator/source_writer.cc   |  11 +-
 .../org/tensorflow/op/BitwiseOps.java         |  13 +-
 .../org/tensorflow/op/DtypesOps.java          |  10 +-
 .../org/tensorflow/op/ImageOps.java           |  65 +--
 .../annotations/org/tensorflow/op/IoOps.java  |  23 +-
 .../org/tensorflow/op/LinalgOps.java          |  98 ++--
 .../org/tensorflow/op/MathOps.java            | 233 +++++-----
 .../annotations/org/tensorflow/op/NnOps.java  | 178 ++++----
 .../annotations/org/tensorflow/op/Ops.java    | 426 +++++++++---------
 .../org/tensorflow/op/QuantizationOps.java    |  23 +-
 .../org/tensorflow/op/RandomOps.java          |  57 +--
 .../org/tensorflow/op/ShapeOps.java           |  48 +-
 .../org/tensorflow/op/SignalOps.java          |  32 +-
 .../org/tensorflow/op/SparseOps.java          | 100 ++--
 .../org/tensorflow/op/StringsOps.java         |  11 +-
 .../org/tensorflow/op/SummaryOps.java         |  13 +-
 .../org/tensorflow/op/TrainOps.java           | 127 +++---
 .../annotations/org/tensorflow/op/XlaOps.java |  43 +-
 .../org/tensorflow/op/bitwise/BitwiseAnd.java |   6 +-
 .../org/tensorflow/op/bitwise/BitwiseOr.java  |   6 +-
 .../org/tensorflow/op/bitwise/BitwiseXor.java |   6 +-
 .../org/tensorflow/op/bitwise/Invert.java     |   6 +-
 .../org/tensorflow/op/bitwise/LeftShift.java  |   6 +-
 .../org/tensorflow/op/bitwise/RightShift.java |   6 +-
 .../tensorflow/op/collective/AllReduce.java   |   6 +-
 .../op/collective/BroadcastRecv.java          |   6 +-
 .../op/collective/BroadcastSend.java          |   6 +-
 .../gen/java/org/tensorflow/op/core/All.java  |   4 +-
 .../gen/java/org/tensorflow/op/core/Any.java  |   4 +-
 .../java/org/tensorflow/op/core/Assign.java   |   6 +-
 .../org/tensorflow/op/core/AssignAdd.java     |   6 +-
 .../op/core/AssignAddVariableOp.java          |   4 +-
 .../org/tensorflow/op/core/AssignSub.java     |   6 +-
 .../op/core/AssignSubVariableOp.java          |   4 +-
 .../tensorflow/op/core/AssignVariableOp.java  |   4 +-
 .../tensorflow/op/core/BarrierInsertMany.java |   4 +-
 .../org/tensorflow/op/core/BatchToSpace.java  |   6 +-
 .../tensorflow/op/core/BatchToSpaceNd.java    |   6 +-
 .../java/org/tensorflow/op/core/Bitcast.java  |   6 +-
 .../op/core/BroadcastDynamicShape.java        |   6 +-
 .../op/core/BroadcastGradientArgs.java        |   6 +-
 .../org/tensorflow/op/core/BroadcastTo.java   |   6 +-
 .../org/tensorflow/op/core/Bucketize.java     |   4 +-
 .../org/tensorflow/op/core/ClipByValue.java   |   6 +-
 .../tensorflow/op/core/CollectiveGather.java  |   6 +-
 .../java/org/tensorflow/op/core/Concat.java   |   6 +-
 .../gen/java/org/tensorflow/op/core/Copy.java |   6 +-
 .../java/org/tensorflow/op/core/CopyHost.java |   6 +-
 .../org/tensorflow/op/core/CountUpTo.java     |   6 +-
 .../java/org/tensorflow/op/core/DeepCopy.java |   6 +-
 .../op/core/DestroyTemporaryVariable.java     |   6 +-
 .../tensorflow/op/core/DummyMemoryCache.java  |   8 +-
 .../tensorflow/op/core/DynamicPartition.java  |   6 +-
 .../org/tensorflow/op/core/DynamicStitch.java |   6 +-
 .../org/tensorflow/op/core/EditDistance.java  |   4 +-
 .../java/org/tensorflow/op/core/Empty.java    |   6 +-
 .../tensorflow/op/core/EmptyTensorList.java   |  10 +-
 .../org/tensorflow/op/core/EnsureShape.java   |   6 +-
 .../java/org/tensorflow/op/core/Enter.java    |   6 +-
 .../gen/java/org/tensorflow/op/core/Exit.java |   6 +-
 .../org/tensorflow/op/core/ExpandDims.java    |   6 +-
 .../op/core/ExtractVolumePatches.java         |   6 +-
 .../gen/java/org/tensorflow/op/core/Fill.java |   6 +-
 .../org/tensorflow/op/core/Fingerprint.java   |   4 +-
 .../java/org/tensorflow/op/core/Gather.java   |   6 +-
 .../java/org/tensorflow/op/core/GatherNd.java |   6 +-
 .../tensorflow/op/core/GetSessionHandle.java  |  10 +-
 .../tensorflow/op/core/GetSessionTensor.java  |   6 +-
 .../tensorflow/op/core/GuaranteeConst.java    |   6 +-
 .../org/tensorflow/op/core/HashTable.java     |  10 +-
 .../op/core/HistogramFixedWidth.java          |   8 +-
 .../java/org/tensorflow/op/core/Identity.java |   6 +-
 .../org/tensorflow/op/core/IdentityN.java     |   6 +-
 .../tensorflow/op/core/ImmutableConst.java    |   6 +-
 .../tensorflow/op/core/InitializeTable.java   |   4 +-
 .../org/tensorflow/op/core/InplaceAdd.java    |   6 +-
 .../org/tensorflow/op/core/InplaceSub.java    |   6 +-
 .../org/tensorflow/op/core/InplaceUpdate.java |   6 +-
 .../op/core/IsVariableInitialized.java        |   4 +-
 .../java/org/tensorflow/op/core/LinSpace.java |   6 +-
 .../tensorflow/op/core/LookupTableExport.java |   6 +-
 .../tensorflow/op/core/LookupTableFind.java   |   6 +-
 .../tensorflow/op/core/LookupTableImport.java |   4 +-
 .../tensorflow/op/core/LookupTableInsert.java |   4 +-
 .../tensorflow/op/core/LookupTableRemove.java |   4 +-
 .../org/tensorflow/op/core/LowerBound.java    |   8 +-
 .../java/org/tensorflow/op/core/MapPeek.java  |   6 +-
 .../org/tensorflow/op/core/MapUnstage.java    |   6 +-
 .../gen/java/org/tensorflow/op/core/Max.java  |   6 +-
 .../java/org/tensorflow/op/core/Merge.java    |   6 +-
 .../gen/java/org/tensorflow/op/core/Min.java  |   6 +-
 .../org/tensorflow/op/core/MirrorPad.java     |   6 +-
 .../org/tensorflow/op/core/MirrorPadGrad.java |   6 +-
 .../tensorflow/op/core/MlirPassthroughOp.java |   6 +-
 .../op/core/MutableDenseHashTable.java        |  10 +-
 .../tensorflow/op/core/MutableHashTable.java  |  10 +-
 .../op/core/MutableHashTableOfTensors.java    |  10 +-
 .../java/org/tensorflow/op/core/Mutex.java    |   8 +-
 .../org/tensorflow/op/core/MutexLock.java     |   8 +-
 .../org/tensorflow/op/core/NcclAllReduce.java |   6 +-
 .../org/tensorflow/op/core/NcclBroadcast.java |   6 +-
 .../org/tensorflow/op/core/NcclReduce.java    |   6 +-
 .../org/tensorflow/op/core/NextIteration.java |   6 +-
 .../java/org/tensorflow/op/core/OneHot.java   |   6 +-
 .../java/org/tensorflow/op/core/OnesLike.java |   6 +-
 .../tensorflow/op/core/OrderedMapPeek.java    |   6 +-
 .../tensorflow/op/core/OrderedMapUnstage.java |   6 +-
 .../gen/java/org/tensorflow/op/core/Pad.java  |   6 +-
 .../tensorflow/op/core/ParallelConcat.java    |   6 +-
 .../op/core/ParallelDynamicStitch.java        |   6 +-
 .../org/tensorflow/op/core/Placeholder.java   |   6 +-
 .../op/core/PlaceholderWithDefault.java       |   6 +-
 .../gen/java/org/tensorflow/op/core/Prod.java |   6 +-
 .../tensorflow/op/core/QuantizedReshape.java  |   6 +-
 .../java/org/tensorflow/op/core/Range.java    |   6 +-
 .../gen/java/org/tensorflow/op/core/Rank.java |   4 +-
 .../tensorflow/op/core/ReadVariableOp.java    |   6 +-
 .../gen/java/org/tensorflow/op/core/Recv.java |   6 +-
 .../org/tensorflow/op/core/ReduceAll.java     |   4 +-
 .../org/tensorflow/op/core/ReduceAny.java     |   4 +-
 .../org/tensorflow/op/core/ReduceMax.java     |   6 +-
 .../org/tensorflow/op/core/ReduceMin.java     |   6 +-
 .../org/tensorflow/op/core/ReduceProd.java    |   6 +-
 .../org/tensorflow/op/core/ReduceSum.java     |   6 +-
 .../java/org/tensorflow/op/core/RefEnter.java |   6 +-
 .../java/org/tensorflow/op/core/RefExit.java  |   6 +-
 .../org/tensorflow/op/core/RefIdentity.java   |   6 +-
 .../java/org/tensorflow/op/core/RefMerge.java |   6 +-
 .../tensorflow/op/core/RefNextIteration.java  |   6 +-
 .../org/tensorflow/op/core/RefSelect.java     |   6 +-
 .../org/tensorflow/op/core/RefSwitch.java     |   6 +-
 .../op/core/RemoteFusedGraphExecute.java      |   6 +-
 .../java/org/tensorflow/op/core/Reshape.java  |   6 +-
 .../tensorflow/op/core/ResourceCountUpTo.java |   6 +-
 .../tensorflow/op/core/ResourceGather.java    |   6 +-
 .../tensorflow/op/core/ResourceGatherNd.java  |   6 +-
 .../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  |   6 +-
 .../tensorflow/op/core/ReverseSequence.java   |   6 +-
 .../gen/java/org/tensorflow/op/core/Roll.java |   6 +-
 .../org/tensorflow/op/core/ScatterAdd.java    |   6 +-
 .../org/tensorflow/op/core/ScatterDiv.java    |   6 +-
 .../org/tensorflow/op/core/ScatterMax.java    |   6 +-
 .../org/tensorflow/op/core/ScatterMin.java    |   6 +-
 .../org/tensorflow/op/core/ScatterMul.java    |   6 +-
 .../org/tensorflow/op/core/ScatterNd.java     |   6 +-
 .../org/tensorflow/op/core/ScatterNdAdd.java  |   6 +-
 .../op/core/ScatterNdNonAliasingAdd.java      |   6 +-
 .../org/tensorflow/op/core/ScatterNdSub.java  |   6 +-
 .../tensorflow/op/core/ScatterNdUpdate.java   |   6 +-
 .../org/tensorflow/op/core/ScatterSub.java    |   6 +-
 .../org/tensorflow/op/core/ScatterUpdate.java |   6 +-
 .../java/org/tensorflow/op/core/Select.java   |   6 +-
 .../gen/java/org/tensorflow/op/core/Send.java |   4 +-
 .../org/tensorflow/op/core/SetDiff1d.java     |   8 +-
 .../java/org/tensorflow/op/core/SetSize.java  |   4 +-
 .../java/org/tensorflow/op/core/Shape.java    |   8 +-
 .../java/org/tensorflow/op/core/ShapeN.java   |   8 +-
 .../gen/java/org/tensorflow/op/core/Size.java |   8 +-
 .../java/org/tensorflow/op/core/Slice.java    |   6 +-
 .../java/org/tensorflow/op/core/Snapshot.java |   6 +-
 .../tensorflow/op/core/SpaceToBatchNd.java    |   6 +-
 .../java/org/tensorflow/op/core/Split.java    |   6 +-
 .../java/org/tensorflow/op/core/SplitV.java   |   6 +-
 .../java/org/tensorflow/op/core/Squeeze.java  |   6 +-
 .../java/org/tensorflow/op/core/Stack.java    |   6 +-
 .../org/tensorflow/op/core/StagePeek.java     |   6 +-
 .../org/tensorflow/op/core/StopGradient.java  |   6 +-
 .../org/tensorflow/op/core/StridedSlice.java  |   6 +-
 .../op/core/StridedSliceAssign.java           |   6 +-
 .../tensorflow/op/core/StridedSliceGrad.java  |   6 +-
 .../gen/java/org/tensorflow/op/core/Sum.java  |   6 +-
 .../org/tensorflow/op/core/SwitchCond.java    |   6 +-
 .../tensorflow/op/core/TemporaryVariable.java |   6 +-
 .../org/tensorflow/op/core/TensorArray.java   |   4 +-
 .../tensorflow/op/core/TensorArrayConcat.java |   6 +-
 .../tensorflow/op/core/TensorArrayGather.java |   6 +-
 .../tensorflow/op/core/TensorArrayPack.java   |   6 +-
 .../tensorflow/op/core/TensorArrayRead.java   |   6 +-
 .../op/core/TensorArrayScatter.java           |   4 +-
 .../tensorflow/op/core/TensorArraySplit.java  |   4 +-
 .../tensorflow/op/core/TensorArrayUnpack.java |   4 +-
 .../tensorflow/op/core/TensorArrayWrite.java  |   4 +-
 .../TensorForestTreeResourceHandleOp.java     |   8 +-
 .../tensorflow/op/core/TensorListConcat.java  |   6 +-
 .../op/core/TensorListConcatLists.java        |  10 +-
 .../op/core/TensorListElementShape.java       |   6 +-
 .../op/core/TensorListFromTensor.java         |  10 +-
 .../tensorflow/op/core/TensorListGather.java  |   6 +-
 .../tensorflow/op/core/TensorListGetItem.java |   6 +-
 .../tensorflow/op/core/TensorListPopBack.java |   6 +-
 .../op/core/TensorListPushBack.java           |  10 +-
 .../op/core/TensorListPushBackBatch.java      |  10 +-
 .../tensorflow/op/core/TensorListReserve.java |  10 +-
 .../tensorflow/op/core/TensorListResize.java  |   8 +-
 .../tensorflow/op/core/TensorListScatter.java |  10 +-
 .../TensorListScatterIntoExistingList.java    |  10 +-
 .../tensorflow/op/core/TensorListSetItem.java |  10 +-
 .../tensorflow/op/core/TensorListSplit.java   |  10 +-
 .../tensorflow/op/core/TensorListStack.java   |   6 +-
 .../op/core/TensorScatterNdAdd.java           |   6 +-
 .../op/core/TensorScatterNdSub.java           |   6 +-
 .../op/core/TensorScatterNdUpdate.java        |   6 +-
 .../op/core/TensorStridedSliceUpdate.java     |   6 +-
 .../gen/java/org/tensorflow/op/core/Tile.java |   6 +-
 .../java/org/tensorflow/op/core/Unbatch.java  |   6 +-
 .../org/tensorflow/op/core/UnbatchGrad.java   |   6 +-
 .../java/org/tensorflow/op/core/Unique.java   |   8 +-
 .../tensorflow/op/core/UniqueWithCounts.java  |   8 +-
 .../org/tensorflow/op/core/UnravelIndex.java  |   6 +-
 .../java/org/tensorflow/op/core/Unstack.java  |   6 +-
 .../java/org/tensorflow/op/core/Unstage.java  |   6 +-
 .../org/tensorflow/op/core/UpperBound.java    |   8 +-
 .../org/tensorflow/op/core/VarHandleOp.java   |  10 +-
 .../java/org/tensorflow/op/core/Variable.java |   6 +-
 .../org/tensorflow/op/core/VariableShape.java |   6 +-
 .../java/org/tensorflow/op/core/Where.java    |   4 +-
 .../org/tensorflow/op/core/ZerosLike.java     |   6 +-
 .../tensorflow/op/data/AssertNextDataset.java |   8 +-
 .../tensorflow/op/data/AutoShardDataset.java  |   8 +-
 .../org/tensorflow/op/data/BatchDataset.java  |   8 +-
 .../op/data/BytesProducedStatsDataset.java    |   8 +-
 .../org/tensorflow/op/data/CSVDataset.java    |   8 +-
 .../org/tensorflow/op/data/CacheDataset.java  |   8 +-
 .../tensorflow/op/data/CacheDatasetV2.java    |   8 +-
 .../op/data/ChooseFastestDataset.java         |   8 +-
 .../op/data/ConcatenateDataset.java           |   8 +-
 .../tensorflow/op/data/DatasetFromGraph.java  |   8 +-
 .../op/data/DatasetToSingleElement.java       |   6 +-
 .../op/data/DenseToSparseBatchDataset.java    |   8 +-
 .../op/data/DirectedInterleaveDataset.java    |   8 +-
 .../op/data/FilterByLastComponentDataset.java |   8 +-
 .../op/data/FixedLengthRecordDataset.java     |   8 +-
 .../op/data/IgnoreErrorsDataset.java          |   8 +-
 .../java/org/tensorflow/op/data/Iterator.java |   8 +-
 .../op/data/IteratorFromStringHandle.java     |   8 +-
 .../tensorflow/op/data/IteratorGetNext.java   |   6 +-
 .../op/data/IteratorGetNextAsOptional.java    |   8 +-
 .../op/data/IteratorGetNextSync.java          |   6 +-
 .../org/tensorflow/op/data/LMDBDataset.java   |   8 +-
 .../op/data/LatencyStatsDataset.java          |   8 +-
 .../org/tensorflow/op/data/LeakyReluGrad.java |   6 +-
 .../op/data/MatchingFilesDataset.java         |   8 +-
 .../op/data/MaxIntraOpParallelismDataset.java |   8 +-
 .../org/tensorflow/op/data/ModelDataset.java  |   8 +-
 .../op/data/MultiDeviceIterator.java          |   8 +-
 .../MultiDeviceIteratorFromStringHandle.java  |   8 +-
 .../MultiDeviceIteratorGetNextFromShard.java  |   6 +-
 .../op/data/NonSerializableDataset.java       |   8 +-
 .../tensorflow/op/data/OptimizeDataset.java   |   8 +-
 .../tensorflow/op/data/OptionalFromValue.java |   8 +-
 .../tensorflow/op/data/OptionalGetValue.java  |   6 +-
 .../org/tensorflow/op/data/OptionalNone.java  |   8 +-
 .../op/data/PaddedBatchDataset.java           |   8 +-
 .../tensorflow/op/data/PrefetchDataset.java   |   8 +-
 .../op/data/PrivateThreadPoolDataset.java     |   8 +-
 .../org/tensorflow/op/data/RandomDataset.java |   8 +-
 .../org/tensorflow/op/data/RangeDataset.java  |   8 +-
 .../tensorflow/op/data/RebatchDataset.java    |   8 +-
 .../org/tensorflow/op/data/RepeatDataset.java |   8 +-
 .../tensorflow/op/data/SamplingDataset.java   |   8 +-
 .../tensorflow/op/data/SerializeIterator.java |   8 +-
 .../op/data/SetStatsAggregatorDataset.java    |   8 +-
 .../org/tensorflow/op/data/ShardDataset.java  |   8 +-
 .../op/data/ShuffleAndRepeatDataset.java      |   8 +-
 .../tensorflow/op/data/ShuffleDataset.java    |   8 +-
 .../org/tensorflow/op/data/SkipDataset.java   |   8 +-
 .../org/tensorflow/op/data/SleepDataset.java  |   8 +-
 .../op/data/SlidingWindowDataset.java         |   8 +-
 .../tensorflow/op/data/SnapshotDataset.java   |   8 +-
 .../op/data/SparseTensorSliceDataset.java     |  10 +-
 .../org/tensorflow/op/data/SqlDataset.java    |   8 +-
 .../op/data/StatsAggregatorHandle.java        |   8 +-
 .../org/tensorflow/op/data/TakeDataset.java   |   8 +-
 .../org/tensorflow/op/data/TensorDataset.java |   8 +-
 .../op/data/TensorSliceDataset.java           |   8 +-
 .../tensorflow/op/data/TextLineDataset.java   |   8 +-
 .../tensorflow/op/data/TfRecordDataset.java   |   8 +-
 .../tensorflow/op/data/ThreadPoolDataset.java |   8 +-
 .../tensorflow/op/data/ThreadPoolHandle.java  |   8 +-
 .../tensorflow/op/data/UnbatchDataset.java    |   8 +-
 .../org/tensorflow/op/data/UniqueDataset.java |   8 +-
 .../op/data/UnwrapDatasetVariant.java         |   8 +-
 .../org/tensorflow/op/data/WindowDataset.java |   8 +-
 .../op/data/WrapDatasetVariant.java           |   8 +-
 .../org/tensorflow/op/data/ZipDataset.java    |   8 +-
 .../AssertCardinalityDataset.java             |   8 +-
 .../data/experimental/AssertNextDataset.java  |   8 +-
 .../data/experimental/AutoShardDataset.java   |   8 +-
 .../BytesProducedStatsDataset.java            |   8 +-
 .../op/data/experimental/CSVDataset.java      |   8 +-
 .../experimental/ChooseFastestDataset.java    |   8 +-
 .../DenseToSparseBatchDataset.java            |   8 +-
 .../DirectedInterleaveDataset.java            |   8 +-
 .../experimental/IgnoreErrorsDataset.java     |   8 +-
 .../experimental/LatencyStatsDataset.java     |   8 +-
 .../op/data/experimental/LmdbDataset.java     |   8 +-
 .../experimental/MatchingFilesDataset.java    |   8 +-
 .../MaxIntraOpParallelismDataset.java         |   8 +-
 .../experimental/NonSerializableDataset.java  |   8 +-
 .../experimental/ParseExampleDataset.java     |   8 +-
 .../PrivateThreadPoolDataset.java             |   8 +-
 .../op/data/experimental/RandomDataset.java   |   8 +-
 .../op/data/experimental/RebatchDataset.java  |   8 +-
 .../SetStatsAggregatorDataset.java            |   8 +-
 .../op/data/experimental/SleepDataset.java    |   8 +-
 .../experimental/SlidingWindowDataset.java    |   8 +-
 .../op/data/experimental/SqlDataset.java      |   8 +-
 .../experimental/StatsAggregatorHandle.java   |   8 +-
 .../data/experimental/ThreadPoolDataset.java  |   8 +-
 .../data/experimental/ThreadPoolHandle.java   |   8 +-
 .../op/data/experimental/UnbatchDataset.java  |   8 +-
 .../op/data/experimental/UniqueDataset.java   |   8 +-
 .../op/debugging/CheckNumerics.java           |   6 +-
 .../op/debugging/DebugGradientIdentity.java   |   6 +-
 .../debugging/DebugGradientRefIdentity.java   |   6 +-
 .../op/debugging/DebugIdentity.java           |   6 +-
 .../op/debugging/DebugNanCount.java           |   4 +-
 .../op/debugging/DebugNumericsSummary.java    |   8 +-
 .../org/tensorflow/op/dtypes/AsString.java    |   4 +-
 .../java/org/tensorflow/op/dtypes/Cast.java   |   6 +-
 .../org/tensorflow/op/dtypes/Complex.java     |   6 +-
 .../java/org/tensorflow/op/dtypes/ToBool.java |   4 +-
 .../BoostedTreesEnsembleResourceHandleOp.java |   8 +-
 ...edTreesQuantileStreamResourceHandleOp.java |   8 +-
 .../tensorflow/op/image/AdjustContrast.java   |   6 +-
 .../org/tensorflow/op/image/AdjustHue.java    |   6 +-
 .../tensorflow/op/image/AdjustSaturation.java |   6 +-
 .../tensorflow/op/image/CropAndResize.java    |   4 +-
 .../op/image/CropAndResizeGradBoxes.java      |   4 +-
 .../op/image/CropAndResizeGradImage.java      |   6 +-
 .../org/tensorflow/op/image/DecodePng.java    |   6 +-
 .../op/image/DrawBoundingBoxes.java           |   6 +-
 .../org/tensorflow/op/image/EncodePng.java    |   4 +-
 .../op/image/ExtractImagePatches.java         |   6 +-
 .../tensorflow/op/image/ExtractJpegShape.java |   6 +-
 .../org/tensorflow/op/image/HsvToRgb.java     |   6 +-
 .../op/image/ImageProjectiveTransformV2.java  |   6 +-
 .../op/image/NonMaxSuppression.java           |   6 +-
 .../op/image/QuantizedResizeBilinear.java     |   6 +-
 .../org/tensorflow/op/image/RandomCrop.java   |   6 +-
 .../org/tensorflow/op/image/ResizeArea.java   |   4 +-
 .../tensorflow/op/image/ResizeBicubic.java    |   4 +-
 .../op/image/ResizeBicubicGrad.java           |   6 +-
 .../tensorflow/op/image/ResizeBilinear.java   |   4 +-
 .../op/image/ResizeBilinearGrad.java          |   6 +-
 .../op/image/ResizeNearestNeighbor.java       |   6 +-
 .../op/image/ResizeNearestNeighborGrad.java   |   6 +-
 .../org/tensorflow/op/image/RgbToHsv.java     |   6 +-
 .../op/image/SampleDistortedBoundingBox.java  |   6 +-
 .../op/image/ScaleAndTranslate.java           |   4 +-
 .../op/image/ScaleAndTranslateGrad.java       |   6 +-
 .../java/org/tensorflow/op/io/DecodeCsv.java  |   6 +-
 .../org/tensorflow/op/io/DecodePaddedRaw.java |   6 +-
 .../java/org/tensorflow/op/io/DecodeRaw.java  |   6 +-
 .../op/io/DeserializeManySparse.java          |   6 +-
 .../java/org/tensorflow/op/io/FifoQueue.java  |   8 +-
 .../op/io/FixedLengthRecordReader.java        |   8 +-
 .../org/tensorflow/op/io/IdentityReader.java  |   8 +-
 .../tensorflow/op/io/PaddingFifoQueue.java    |   8 +-
 .../org/tensorflow/op/io/ParseTensor.java     |   6 +-
 .../org/tensorflow/op/io/PriorityQueue.java   |   8 +-
 .../org/tensorflow/op/io/QueueDequeue.java    |   6 +-
 .../tensorflow/op/io/QueueDequeueMany.java    |   6 +-
 .../tensorflow/op/io/QueueDequeueUpTo.java    |   6 +-
 .../tensorflow/op/io/RandomShuffleQueue.java  |   8 +-
 .../tensorflow/op/io/SerializeManySparse.java |   8 +-
 .../org/tensorflow/op/io/SerializeSparse.java |   8 +-
 .../org/tensorflow/op/io/SerializeTensor.java |   4 +-
 .../org/tensorflow/op/io/TextLineReader.java  |   8 +-
 .../org/tensorflow/op/io/TfRecordReader.java  |   8 +-
 .../org/tensorflow/op/io/WholeFileReader.java |   8 +-
 .../org/tensorflow/op/linalg/BandPart.java    |   6 +-
 .../tensorflow/op/linalg/BatchCholesky.java   |   6 +-
 .../op/linalg/BatchCholeskyGrad.java          |   6 +-
 .../op/linalg/BatchMatrixBandPart.java        |   6 +-
 .../op/linalg/BatchMatrixDeterminant.java     |   6 +-
 .../tensorflow/op/linalg/BatchMatrixDiag.java |   6 +-
 .../op/linalg/BatchMatrixDiagPart.java        |   6 +-
 .../op/linalg/BatchMatrixInverse.java         |   6 +-
 .../op/linalg/BatchMatrixSetDiag.java         |   6 +-
 .../op/linalg/BatchMatrixSolve.java           |   6 +-
 .../op/linalg/BatchMatrixSolveLs.java         |   6 +-
 .../op/linalg/BatchMatrixTriangularSolve.java |   6 +-
 .../op/linalg/BatchSelfAdjointEig.java        |   6 +-
 .../org/tensorflow/op/linalg/BatchSvd.java    |   6 +-
 .../org/tensorflow/op/linalg/Cholesky.java    |   6 +-
 .../tensorflow/op/linalg/CholeskyGrad.java    |   6 +-
 .../op/linalg/ConjugateTranspose.java         |   6 +-
 .../java/org/tensorflow/op/linalg/Cross.java  |   6 +-
 .../java/org/tensorflow/op/linalg/Det.java    |   6 +-
 .../java/org/tensorflow/op/linalg/Eig.java    |   6 +-
 .../java/org/tensorflow/op/linalg/Einsum.java |   6 +-
 .../tensorflow/op/linalg/EuclideanNorm.java   |   6 +-
 .../java/org/tensorflow/op/linalg/Inv.java    |   6 +-
 .../op/linalg/LogMatrixDeterminant.java       |   6 +-
 .../gen/java/org/tensorflow/op/linalg/Lu.java |   8 +-
 .../java/org/tensorflow/op/linalg/MatMul.java |   6 +-
 .../org/tensorflow/op/linalg/MatrixDiag.java  |   6 +-
 .../tensorflow/op/linalg/MatrixDiagPart.java  |   6 +-
 .../op/linalg/MatrixDiagPartV3.java           |   6 +-
 .../tensorflow/op/linalg/MatrixDiagV3.java    |   6 +-
 .../tensorflow/op/linalg/MatrixLogarithm.java |   6 +-
 .../tensorflow/op/linalg/MatrixSetDiag.java   |   6 +-
 .../tensorflow/op/linalg/MatrixSolveLs.java   |   6 +-
 .../gen/java/org/tensorflow/op/linalg/Qr.java |   6 +-
 .../tensorflow/op/linalg/QuantizedMatMul.java |   6 +-
 .../op/linalg/QuantizedMatMulWithBias.java    |   6 +-
 .../QuantizedMatMulWithBiasAndRelu.java       |   6 +-
 ...zedMatMulWithBiasAndReluAndRequantize.java |   6 +-
 .../tensorflow/op/linalg/SelfAdjointEig.java  |   6 +-
 .../java/org/tensorflow/op/linalg/Solve.java  |   6 +-
 .../java/org/tensorflow/op/linalg/Sqrtm.java  |   6 +-
 .../java/org/tensorflow/op/linalg/Svd.java    |   6 +-
 .../org/tensorflow/op/linalg/TensorDiag.java  |   6 +-
 .../tensorflow/op/linalg/TensorDiagPart.java  |   6 +-
 .../org/tensorflow/op/linalg/Transpose.java   |   6 +-
 .../tensorflow/op/linalg/TriangularSolve.java |   6 +-
 .../op/linalg/TridiagonalMatMul.java          |   6 +-
 .../op/linalg/TridiagonalSolve.java           |   6 +-
 .../sparse/CSRSparseMatrixComponents.java     |   6 +-
 .../linalg/sparse/CSRSparseMatrixToDense.java |   6 +-
 .../sparse/CSRSparseMatrixToSparseTensor.java |   6 +-
 .../linalg/sparse/DenseToCSRSparseMatrix.java |  10 +-
 .../op/linalg/sparse/SparseMatrixAdd.java     |  10 +-
 .../op/linalg/sparse/SparseMatrixMatMul.java  |   6 +-
 .../op/linalg/sparse/SparseMatrixMul.java     |  10 +-
 .../op/linalg/sparse/SparseMatrixSoftmax.java |  10 +-
 .../sparse/SparseMatrixSoftmaxGrad.java       |  10 +-
 .../sparse/SparseMatrixSparseCholesky.java    |  10 +-
 .../sparse/SparseMatrixSparseMatMul.java      |  10 +-
 .../linalg/sparse/SparseMatrixTranspose.java  |  10 +-
 .../op/linalg/sparse/SparseMatrixZeros.java   |  10 +-
 .../sparse/SparseTensorToCSRSparseMatrix.java |  10 +-
 .../gen/java/org/tensorflow/op/math/Abs.java  |   6 +-
 .../org/tensorflow/op/math/AccumulateN.java   |   6 +-
 .../gen/java/org/tensorflow/op/math/Acos.java |   6 +-
 .../java/org/tensorflow/op/math/Acosh.java    |   6 +-
 .../gen/java/org/tensorflow/op/math/Add.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/AddN.java |   6 +-
 .../java/org/tensorflow/op/math/Angle.java    |   8 +-
 .../tensorflow/op/math/ApproximateEqual.java  |   4 +-
 .../java/org/tensorflow/op/math/ArgMax.java   |   8 +-
 .../java/org/tensorflow/op/math/ArgMin.java   |   8 +-
 .../gen/java/org/tensorflow/op/math/Asin.java |   6 +-
 .../java/org/tensorflow/op/math/Asinh.java    |   6 +-
 .../gen/java/org/tensorflow/op/math/Atan.java |   6 +-
 .../java/org/tensorflow/op/math/Atan2.java    |   6 +-
 .../java/org/tensorflow/op/math/Atanh.java    |   6 +-
 .../org/tensorflow/op/math/BesselI0e.java     |   6 +-
 .../org/tensorflow/op/math/BesselI1e.java     |   6 +-
 .../java/org/tensorflow/op/math/Betainc.java  |   6 +-
 .../java/org/tensorflow/op/math/Bincount.java |   6 +-
 .../gen/java/org/tensorflow/op/math/Ceil.java |   6 +-
 .../tensorflow/op/math/CompareAndBitpack.java |   4 +-
 .../org/tensorflow/op/math/ComplexAbs.java    |   8 +-
 .../gen/java/org/tensorflow/op/math/Conj.java |   6 +-
 .../gen/java/org/tensorflow/op/math/Cos.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Cosh.java |   6 +-
 .../java/org/tensorflow/op/math/Cumprod.java  |   6 +-
 .../java/org/tensorflow/op/math/Cumsum.java   |   6 +-
 .../op/math/CumulativeLogsumexp.java          |   6 +-
 .../java/org/tensorflow/op/math/Digamma.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Div.java  |   6 +-
 .../java/org/tensorflow/op/math/DivNoNan.java |   6 +-
 .../java/org/tensorflow/op/math/Equal.java    |   4 +-
 .../gen/java/org/tensorflow/op/math/Erf.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Erfc.java |   6 +-
 .../gen/java/org/tensorflow/op/math/Exp.java  |   6 +-
 .../java/org/tensorflow/op/math/Expm1.java    |   6 +-
 .../java/org/tensorflow/op/math/Floor.java    |   6 +-
 .../java/org/tensorflow/op/math/FloorDiv.java |   6 +-
 .../java/org/tensorflow/op/math/FloorMod.java |   6 +-
 .../java/org/tensorflow/op/math/Greater.java  |   4 +-
 .../org/tensorflow/op/math/GreaterEqual.java  |   4 +-
 .../java/org/tensorflow/op/math/Igamma.java   |   6 +-
 .../org/tensorflow/op/math/IgammaGradA.java   |   6 +-
 .../java/org/tensorflow/op/math/Igammac.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Imag.java |   8 +-
 .../tensorflow/op/math/InvertPermutation.java |   6 +-
 .../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   |   6 +-
 .../gen/java/org/tensorflow/op/math/Log.java  |   6 +-
 .../java/org/tensorflow/op/math/Log1p.java    |   6 +-
 .../java/org/tensorflow/op/math/Maximum.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Mean.java |   6 +-
 .../java/org/tensorflow/op/math/Minimum.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Mod.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Mul.java  |   6 +-
 .../java/org/tensorflow/op/math/MulNoNan.java |   6 +-
 .../java/org/tensorflow/op/math/Ndtri.java    |   6 +-
 .../gen/java/org/tensorflow/op/math/Neg.java  |   6 +-
 .../org/tensorflow/op/math/NextAfter.java     |   6 +-
 .../java/org/tensorflow/op/math/NotEqual.java |   4 +-
 .../org/tensorflow/op/math/Polygamma.java     |   6 +-
 .../tensorflow/op/math/PopulationCount.java   |   4 +-
 .../gen/java/org/tensorflow/op/math/Pow.java  |   6 +-
 .../org/tensorflow/op/math/QuantizedAdd.java  |   6 +-
 .../org/tensorflow/op/math/QuantizedMul.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Real.java |   8 +-
 .../java/org/tensorflow/op/math/RealDiv.java  |   6 +-
 .../org/tensorflow/op/math/Reciprocal.java    |   6 +-
 .../tensorflow/op/math/ReciprocalGrad.java    |   6 +-
 .../math/RequantizationRangePerChannel.java   |   4 +-
 .../op/math/RequantizePerChannel.java         |   6 +-
 .../gen/java/org/tensorflow/op/math/Rint.java |   6 +-
 .../java/org/tensorflow/op/math/Round.java    |   6 +-
 .../java/org/tensorflow/op/math/Rsqrt.java    |   6 +-
 .../org/tensorflow/op/math/RsqrtGrad.java     |   6 +-
 .../org/tensorflow/op/math/SegmentMax.java    |   6 +-
 .../org/tensorflow/op/math/SegmentMean.java   |   6 +-
 .../org/tensorflow/op/math/SegmentMin.java    |   6 +-
 .../org/tensorflow/op/math/SegmentProd.java   |   6 +-
 .../org/tensorflow/op/math/SegmentSum.java    |   6 +-
 .../java/org/tensorflow/op/math/Sigmoid.java  |   6 +-
 .../org/tensorflow/op/math/SigmoidGrad.java   |   6 +-
 .../gen/java/org/tensorflow/op/math/Sign.java |   6 +-
 .../gen/java/org/tensorflow/op/math/Sin.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Sinh.java |   6 +-
 .../org/tensorflow/op/math/SobolSample.java   |   6 +-
 .../java/org/tensorflow/op/math/Softplus.java |   6 +-
 .../org/tensorflow/op/math/SoftplusGrad.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Sqrt.java |   6 +-
 .../java/org/tensorflow/op/math/SqrtGrad.java |   6 +-
 .../java/org/tensorflow/op/math/Square.java   |   6 +-
 .../tensorflow/op/math/SquaredDifference.java |   6 +-
 .../gen/java/org/tensorflow/op/math/Sub.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Tan.java  |   6 +-
 .../gen/java/org/tensorflow/op/math/Tanh.java |   6 +-
 .../java/org/tensorflow/op/math/TanhGrad.java |   6 +-
 .../org/tensorflow/op/math/TruncateDiv.java   |   6 +-
 .../org/tensorflow/op/math/TruncateMod.java   |   6 +-
 .../op/math/UnsortedSegmentMax.java           |   6 +-
 .../op/math/UnsortedSegmentMin.java           |   6 +-
 .../op/math/UnsortedSegmentProd.java          |   6 +-
 .../op/math/UnsortedSegmentSum.java           |   6 +-
 .../java/org/tensorflow/op/math/Xdivy.java    |   6 +-
 .../java/org/tensorflow/op/math/Xlog1py.java  |   6 +-
 .../java/org/tensorflow/op/math/Xlogy.java    |   6 +-
 .../gen/java/org/tensorflow/op/math/Zeta.java |   6 +-
 .../java/org/tensorflow/op/math/erfinv.java   |   6 +-
 .../org/tensorflow/op/math/special/Dawsn.java |   6 +-
 .../tensorflow/op/math/special/Expint.java    |   6 +-
 .../op/math/special/FresnelCos.java           |   6 +-
 .../op/math/special/FresnelSin.java           |   6 +-
 .../tensorflow/op/math/special/Spence.java    |   6 +-
 .../java/org/tensorflow/op/nn/AvgPool.java    |   6 +-
 .../java/org/tensorflow/op/nn/AvgPool3d.java  |   6 +-
 .../org/tensorflow/op/nn/AvgPool3dGrad.java   |   6 +-
 .../org/tensorflow/op/nn/AvgPoolGrad.java     |   6 +-
 .../nn/BatchNormWithGlobalNormalization.java  |   6 +-
 .../BatchNormWithGlobalNormalizationGrad.java |   6 +-
 .../java/org/tensorflow/op/nn/BiasAdd.java    |   6 +-
 .../org/tensorflow/op/nn/BiasAddGrad.java     |   6 +-
 .../java/org/tensorflow/op/nn/BlockLSTM.java  |   6 +-
 .../org/tensorflow/op/nn/BlockLSTMGrad.java   |   6 +-
 .../gen/java/org/tensorflow/op/nn/Conv2d.java |   6 +-
 .../op/nn/Conv2dBackpropFilter.java           |   6 +-
 .../tensorflow/op/nn/Conv2dBackpropInput.java |   6 +-
 .../gen/java/org/tensorflow/op/nn/Conv3d.java |   6 +-
 .../op/nn/Conv3dBackpropFilter.java           |   6 +-
 .../tensorflow/op/nn/Conv3dBackpropInput.java |   6 +-
 .../op/nn/CtcBeamSearchDecoder.java           |   6 +-
 .../tensorflow/op/nn/CtcGreedyDecoder.java    |   6 +-
 .../java/org/tensorflow/op/nn/CtcLoss.java    |   6 +-
 .../java/org/tensorflow/op/nn/CudnnRNN.java   |   6 +-
 .../tensorflow/op/nn/CudnnRNNBackprop.java    |   6 +-
 .../op/nn/CudnnRNNCanonicalToParams.java      |   6 +-
 .../op/nn/CudnnRNNParamsToCanonical.java      |   6 +-
 .../tensorflow/op/nn/CudnnRnnParamsSize.java  |   6 +-
 .../tensorflow/op/nn/DataFormatDimMap.java    |   6 +-
 .../op/nn/DataFormatVecPermute.java           |   6 +-
 .../org/tensorflow/op/nn/DepthToSpace.java    |   6 +-
 .../op/nn/DepthwiseConv2dNative.java          |   6 +-
 .../DepthwiseConv2dNativeBackpropFilter.java  |   6 +-
 .../DepthwiseConv2dNativeBackpropInput.java   |   6 +-
 .../java/org/tensorflow/op/nn/Dilation2d.java |   6 +-
 .../op/nn/Dilation2dBackpropFilter.java       |   6 +-
 .../op/nn/Dilation2dBackpropInput.java        |   6 +-
 .../gen/java/org/tensorflow/op/nn/Elu.java    |   6 +-
 .../java/org/tensorflow/op/nn/EluGrad.java    |   6 +-
 .../tensorflow/op/nn/FractionalAvgPool.java   |   6 +-
 .../op/nn/FractionalAvgPoolGrad.java          |   6 +-
 .../tensorflow/op/nn/FractionalMaxPool.java   |   6 +-
 .../op/nn/FractionalMaxPoolGrad.java          |   6 +-
 .../org/tensorflow/op/nn/FusedBatchNorm.java  |   6 +-
 .../tensorflow/op/nn/FusedBatchNormGrad.java  |   6 +-
 .../org/tensorflow/op/nn/FusedPadConv2d.java  |   6 +-
 .../op/nn/FusedResizeAndPadConv2d.java        |   6 +-
 .../org/tensorflow/op/nn/GRUBlockCell.java    |   6 +-
 .../tensorflow/op/nn/GRUBlockCellGrad.java    |   6 +-
 .../gen/java/org/tensorflow/op/nn/InTopK.java |   4 +-
 .../java/org/tensorflow/op/nn/InvGrad.java    |   6 +-
 .../gen/java/org/tensorflow/op/nn/L2Loss.java |   6 +-
 .../org/tensorflow/op/nn/LSTMBlockCell.java   |   6 +-
 .../tensorflow/op/nn/LSTMBlockCellGrad.java   |   6 +-
 .../java/org/tensorflow/op/nn/LeakyRelu.java  |   6 +-
 .../op/nn/LocalResponseNormalization.java     |   6 +-
 .../op/nn/LocalResponseNormalizationGrad.java |   6 +-
 .../java/org/tensorflow/op/nn/LogSoftmax.java |   6 +-
 .../java/org/tensorflow/op/nn/MaxPool.java    |   6 +-
 .../java/org/tensorflow/op/nn/MaxPool3d.java  |   6 +-
 .../org/tensorflow/op/nn/MaxPool3dGrad.java   |   6 +-
 .../tensorflow/op/nn/MaxPool3dGradGrad.java   |   6 +-
 .../org/tensorflow/op/nn/MaxPoolGrad.java     |   6 +-
 .../org/tensorflow/op/nn/MaxPoolGradGrad.java |   6 +-
 .../op/nn/MaxPoolGradGradWithArgmax.java      |   6 +-
 .../op/nn/MaxPoolGradWithArgmax.java          |   6 +-
 .../tensorflow/op/nn/MaxPoolWithArgmax.java   |   8 +-
 .../java/org/tensorflow/op/nn/NthElement.java |   6 +-
 .../tensorflow/op/nn/QuantizedAvgPool.java    |   6 +-
 ...tizedBatchNormWithGlobalNormalization.java |   6 +-
 .../tensorflow/op/nn/QuantizedBiasAdd.java    |   6 +-
 .../op/nn/QuantizedConv2DAndRelu.java         |   6 +-
 .../QuantizedConv2DAndReluAndRequantize.java  |   6 +-
 .../op/nn/QuantizedConv2DAndRequantize.java   |   6 +-
 .../op/nn/QuantizedConv2DPerChannel.java      |   6 +-
 .../op/nn/QuantizedConv2DWithBias.java        |   6 +-
 .../op/nn/QuantizedConv2DWithBiasAndRelu.java |   6 +-
 ...zedConv2DWithBiasAndReluAndRequantize.java |   6 +-
 .../QuantizedConv2DWithBiasAndRequantize.java |   6 +-
 ...WithBiasSignedSumAndReluAndRequantize.java |   6 +-
 .../nn/QuantizedConv2DWithBiasSumAndRelu.java |   6 +-
 ...Conv2DWithBiasSumAndReluAndRequantize.java |   6 +-
 .../org/tensorflow/op/nn/QuantizedConv2d.java |   6 +-
 .../op/nn/QuantizedDepthwiseConv2D.java       |   6 +-
 .../nn/QuantizedDepthwiseConv2DWithBias.java  |   6 +-
 ...antizedDepthwiseConv2DWithBiasAndRelu.java |   6 +-
 ...iseConv2DWithBiasAndReluAndRequantize.java |   6 +-
 .../op/nn/QuantizedInstanceNorm.java          |   6 +-
 .../tensorflow/op/nn/QuantizedMaxPool.java    |   6 +-
 .../org/tensorflow/op/nn/QuantizedRelu.java   |   6 +-
 .../org/tensorflow/op/nn/QuantizedRelu6.java  |   6 +-
 .../org/tensorflow/op/nn/QuantizedReluX.java  |   6 +-
 .../gen/java/org/tensorflow/op/nn/Relu.java   |   6 +-
 .../gen/java/org/tensorflow/op/nn/Relu6.java  |   6 +-
 .../java/org/tensorflow/op/nn/Relu6Grad.java  |   6 +-
 .../java/org/tensorflow/op/nn/ReluGrad.java   |   6 +-
 .../gen/java/org/tensorflow/op/nn/Selu.java   |   6 +-
 .../java/org/tensorflow/op/nn/SeluGrad.java   |   6 +-
 .../java/org/tensorflow/op/nn/Softmax.java    |   6 +-
 .../op/nn/SoftmaxCrossEntropyWithLogits.java  |   6 +-
 .../java/org/tensorflow/op/nn/Softsign.java   |   6 +-
 .../org/tensorflow/op/nn/SoftsignGrad.java    |   6 +-
 .../org/tensorflow/op/nn/SpaceToBatch.java    |   6 +-
 .../org/tensorflow/op/nn/SpaceToDepth.java    |   6 +-
 .../SparseSoftmaxCrossEntropyWithLogits.java  |   6 +-
 .../gen/java/org/tensorflow/op/nn/TopK.java   |   6 +-
 .../op/quantization/Dequantize.java           |   8 +-
 .../tensorflow/op/quantization/Quantize.java  |   6 +-
 .../quantization/QuantizeAndDequantize.java   |   6 +-
 .../QuantizeDownAndShrinkRange.java           |   6 +-
 .../op/quantization/QuantizedConcat.java      |   6 +-
 .../QuantizedMatMulWithBiasAndDequantize.java |   6 +-
 .../QuantizedMatMulWithBiasAndRequantize.java |   6 +-
 .../op/quantization/RequantizationRange.java  |   4 +-
 .../op/quantization/Requantize.java           |   6 +-
 .../tensorflow/op/ragged/RaggedGather.java    |   6 +-
 .../org/tensorflow/op/ragged/RaggedRange.java |   8 +-
 .../op/ragged/RaggedTensorFromVariant.java    |   8 +-
 .../op/ragged/RaggedTensorToSparse.java       |   6 +-
 .../op/ragged/RaggedTensorToTensor.java       |   6 +-
 .../op/ragged/RaggedTensorToVariant.java      |  10 +-
 .../org/tensorflow/op/random/Multinomial.java |   8 +-
 .../op/random/NonDeterministicInts.java       |   8 +-
 .../random/ParameterizedTruncatedNormal.java  |   6 +-
 .../org/tensorflow/op/random/RandomGamma.java |   6 +-
 .../tensorflow/op/random/RandomGammaGrad.java |   6 +-
 .../tensorflow/op/random/RandomPoisson.java   |   8 +-
 .../tensorflow/op/random/RandomShuffle.java   |   6 +-
 .../op/random/RandomStandardNormal.java       |   6 +-
 .../tensorflow/op/random/RandomUniform.java   |   6 +-
 .../op/random/RandomUniformInt.java           |   6 +-
 .../op/random/StatefulRandomBinomial.java     |   8 +-
 .../op/random/StatefulStandardNormal.java     |   8 +-
 .../op/random/StatefulTruncatedNormal.java    |   8 +-
 .../tensorflow/op/random/StatefulUniform.java |   8 +-
 .../op/random/StatefulUniformFullInt.java     |   6 +-
 .../op/random/StatefulUniformInt.java         |   6 +-
 .../op/random/StatelessMultinomial.java       |   8 +-
 .../op/random/StatelessRandomBinomial.java    |   8 +-
 .../op/random/StatelessRandomGamma.java       |   6 +-
 .../op/random/StatelessRandomNormal.java      |   8 +-
 .../op/random/StatelessRandomPoisson.java     |   6 +-
 .../op/random/StatelessRandomUniform.java     |   8 +-
 .../random/StatelessRandomUniformFullInt.java |   6 +-
 .../op/random/StatelessRandomUniformInt.java  |   6 +-
 .../op/random/StatelessTruncatedNormal.java   |   8 +-
 .../tensorflow/op/random/TruncatedNormal.java |   6 +-
 .../org/tensorflow/op/signal/BatchFft.java    |   8 +-
 .../org/tensorflow/op/signal/BatchFft2d.java  |   8 +-
 .../org/tensorflow/op/signal/BatchFft3d.java  |   8 +-
 .../org/tensorflow/op/signal/BatchIfft.java   |   8 +-
 .../org/tensorflow/op/signal/BatchIfft2d.java |   8 +-
 .../org/tensorflow/op/signal/BatchIfft3d.java |   8 +-
 .../java/org/tensorflow/op/signal/Fft.java    |   6 +-
 .../java/org/tensorflow/op/signal/Fft2d.java  |   6 +-
 .../java/org/tensorflow/op/signal/Fft3d.java  |   6 +-
 .../java/org/tensorflow/op/signal/Ifft.java   |   6 +-
 .../java/org/tensorflow/op/signal/Ifft2d.java |   6 +-
 .../java/org/tensorflow/op/signal/Ifft3d.java |   6 +-
 .../java/org/tensorflow/op/signal/Irfft.java  |   8 +-
 .../org/tensorflow/op/signal/Irfft2d.java     |   8 +-
 .../org/tensorflow/op/signal/Irfft3d.java     |   8 +-
 .../java/org/tensorflow/op/signal/Rfft.java   |   6 +-
 .../java/org/tensorflow/op/signal/Rfft2d.java |   6 +-
 .../java/org/tensorflow/op/signal/Rfft3d.java |   6 +-
 .../op/sparse/AddManySparseToTensorsMap.java  |   4 +-
 .../op/sparse/AddSparseToTensorsMap.java      |   4 +-
 .../op/sparse/DenseToDenseSetOperation.java   |   6 +-
 .../op/sparse/DenseToSparseSetOperation.java  |   6 +-
 .../op/sparse/DeserializeSparse.java          |   6 +-
 .../SparseAccumulatorApplyGradient.java       |   4 +-
 .../sparse/SparseAccumulatorTakeGradient.java |   6 +-
 .../org/tensorflow/op/sparse/SparseAdd.java   |   6 +-
 .../tensorflow/op/sparse/SparseAddGrad.java   |   6 +-
 .../tensorflow/op/sparse/SparseConcat.java    |   6 +-
 .../sparse/SparseConditionalAccumulator.java  |   4 +-
 .../org/tensorflow/op/sparse/SparseCross.java |   6 +-
 .../op/sparse/SparseDenseCwiseAdd.java        |   6 +-
 .../op/sparse/SparseDenseCwiseDiv.java        |   6 +-
 .../op/sparse/SparseDenseCwiseMul.java        |   6 +-
 .../op/sparse/SparseFillEmptyRows.java        |   6 +-
 .../op/sparse/SparseFillEmptyRowsGrad.java    |   6 +-
 .../tensorflow/op/sparse/SparseMatMul.java    |   4 +-
 .../tensorflow/op/sparse/SparseReduceMax.java |   6 +-
 .../op/sparse/SparseReduceMaxSparse.java      |   6 +-
 .../tensorflow/op/sparse/SparseReduceSum.java |   6 +-
 .../op/sparse/SparseReduceSumSparse.java      |   6 +-
 .../tensorflow/op/sparse/SparseReorder.java   |   6 +-
 .../op/sparse/SparseSegmentMean.java          |   6 +-
 .../op/sparse/SparseSegmentMeanGrad.java      |   6 +-
 .../SparseSegmentMeanWithNumSegments.java     |   6 +-
 .../op/sparse/SparseSegmentSqrtN.java         |   6 +-
 .../op/sparse/SparseSegmentSqrtNGrad.java     |   6 +-
 .../SparseSegmentSqrtNWithNumSegments.java    |   6 +-
 .../op/sparse/SparseSegmentSum.java           |   6 +-
 .../SparseSegmentSumWithNumSegments.java      |   6 +-
 .../org/tensorflow/op/sparse/SparseSlice.java |   6 +-
 .../tensorflow/op/sparse/SparseSliceGrad.java |   6 +-
 .../tensorflow/op/sparse/SparseSoftmax.java   |   6 +-
 .../op/sparse/SparseSparseMaximum.java        |   6 +-
 .../op/sparse/SparseSparseMinimum.java        |   6 +-
 .../org/tensorflow/op/sparse/SparseSplit.java |   6 +-
 .../op/sparse/SparseTensorDenseAdd.java       |   6 +-
 .../op/sparse/SparseTensorDenseMatMul.java    |   6 +-
 .../tensorflow/op/sparse/SparseToDense.java   |   6 +-
 .../op/sparse/SparseToSparseSetOperation.java |   6 +-
 .../sparse/TakeManySparseFromTensorsMap.java  |   6 +-
 .../tensorflow/op/strings/StringNGrams.java   |   6 +-
 .../org/tensorflow/op/strings/Substr.java     |   4 +-
 .../org/tensorflow/op/strings/ToNumber.java   |   6 +-
 .../tensorflow/op/strings/UnicodeDecode.java  |   6 +-
 .../op/strings/UnicodeDecodeWithOffsets.java  |   6 +-
 .../tensorflow/op/strings/UnicodeEncode.java  |   4 +-
 .../op/strings/UnsortedSegmentJoin.java       |   4 +-
 .../op/summary/HistogramSummary.java          |   4 +-
 .../tensorflow/op/summary/ImageSummary.java   |   3 +-
 .../tensorflow/op/summary/ScalarSummary.java  |   4 +-
 .../tensorflow/op/summary/SummaryWriter.java  |   8 +-
 .../tensorflow/op/summary/TensorSummary.java  |   4 +-
 .../op/summary/WriteHistogramSummary.java     |   4 +-
 .../op/summary/WriteImageSummary.java         |   4 +-
 .../op/summary/WriteScalarSummary.java        |   4 +-
 .../tensorflow/op/summary/WriteSummary.java   |   4 +-
 .../java/org/tensorflow/op/tpu/AllToAll.java  |   6 +-
 .../tensorflow/op/tpu/CollectivePermute.java  |   6 +-
 .../tensorflow/op/tpu/CrossReplicaSum.java    |   6 +-
 .../tpu/EnqueueTPUEmbeddingSparseBatch.java   |   4 +-
 .../EnqueueTPUEmbeddingSparseTensorBatch.java |   4 +-
 .../org/tensorflow/op/tpu/InfeedDequeue.java  |   6 +-
 .../tensorflow/op/tpu/InfeedDequeueTuple.java |   6 +-
 .../org/tensorflow/op/tpu/InfeedEnqueue.java  |   4 +-
 .../org/tensorflow/op/tpu/OutfeedDequeue.java |   6 +-
 .../op/tpu/OutfeedDequeueTuple.java           |   6 +-
 .../org/tensorflow/op/tpu/OutfeedEnqueue.java |   4 +-
 .../org/tensorflow/op/tpu/Prelinearize.java   |  10 +-
 .../tensorflow/op/tpu/PrelinearizeTuple.java  |   8 +-
 .../tensorflow/op/tpu/TPUReplicatedInput.java |   6 +-
 .../op/tpu/TPUReplicatedOutput.java           |   6 +-
 .../op/train/AccumulatorApplyGradient.java    |   4 +-
 .../op/train/AccumulatorTakeGradient.java     |   6 +-
 .../org/tensorflow/op/train/ApplyAdaMax.java  |   6 +-
 .../tensorflow/op/train/ApplyAdadelta.java    |   6 +-
 .../org/tensorflow/op/train/ApplyAdagrad.java |   6 +-
 .../tensorflow/op/train/ApplyAdagradDa.java   |   6 +-
 .../tensorflow/op/train/ApplyAdagradV2.java   |   6 +-
 .../org/tensorflow/op/train/ApplyAdam.java    |   6 +-
 .../org/tensorflow/op/train/ApplyAddSign.java |   6 +-
 .../op/train/ApplyCenteredRmsProp.java        |   6 +-
 .../org/tensorflow/op/train/ApplyFtrl.java    |   6 +-
 .../op/train/ApplyGradientDescent.java        |   6 +-
 .../tensorflow/op/train/ApplyMomentum.java    |   6 +-
 .../tensorflow/op/train/ApplyPowerSign.java   |   6 +-
 .../op/train/ApplyProximalAdagrad.java        |   6 +-
 .../train/ApplyProximalGradientDescent.java   |   6 +-
 .../org/tensorflow/op/train/ApplyRmsProp.java |   6 +-
 .../org/tensorflow/op/train/BatchMatMul.java  |   6 +-
 .../op/train/ConditionalAccumulator.java      |   4 +-
 .../tensorflow/op/train/PreventGradient.java  |   6 +-
 .../ResourceAccumulatorApplyGradient.java     |   4 +-
 .../ResourceAccumulatorTakeGradient.java      |   6 +-
 .../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 |  10 +-
 .../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 |   6 +-
 .../org/tensorflow/op/train/RestoreSlice.java |   6 +-
 .../op/train/SparseApplyAdadelta.java         |   6 +-
 .../op/train/SparseApplyAdagrad.java          |   6 +-
 .../op/train/SparseApplyAdagradDa.java        |   6 +-
 .../op/train/SparseApplyCenteredRmsProp.java  |   6 +-
 .../tensorflow/op/train/SparseApplyFtrl.java  |   6 +-
 .../op/train/SparseApplyMomentum.java         |   6 +-
 .../op/train/SparseApplyProximalAdagrad.java  |   6 +-
 .../SparseApplyProximalGradientDescent.java   |   6 +-
 .../op/train/SparseApplyRmsProp.java          |   6 +-
 .../org/tensorflow/op/train/TileGrad.java     |   6 +-
 .../tensorflow/op/xla/BroadcastHelper.java    |   6 +-
 .../org/tensorflow/op/xla/ClusterOutput.java  |   6 +-
 .../gen/java/org/tensorflow/op/xla/Conv.java  |   6 +-
 .../gen/java/org/tensorflow/op/xla/Dot.java   |   6 +-
 .../org/tensorflow/op/xla/DynamicSlice.java   |   6 +-
 .../tensorflow/op/xla/DynamicUpdateSlice.java |   6 +-
 .../java/org/tensorflow/op/xla/Einsum.java    |   6 +-
 .../java/org/tensorflow/op/xla/Gather.java    |   6 +-
 .../org/tensorflow/op/xla/KeyValueSort.java   |   6 +-
 .../gen/java/org/tensorflow/op/xla/Pad.java   |   6 +-
 .../gen/java/org/tensorflow/op/xla/Recv.java  |   6 +-
 .../org/tensorflow/op/xla/SelfAdjointEig.java |   6 +-
 .../gen/java/org/tensorflow/op/xla/Send.java  |   4 +-
 .../java/org/tensorflow/op/xla/Sharding.java  |   6 +-
 .../gen/java/org/tensorflow/op/xla/Sort.java  |   6 +-
 .../gen/java/org/tensorflow/op/xla/Svd.java   |   6 +-
 .../org/tensorflow/AbstractOperation.java     |   3 +-
 .../main/java/org/tensorflow/DataType.java    |   5 +-
 .../src/main/java/org/tensorflow/Operand.java |   2 +-
 .../main/java/org/tensorflow/Operation.java   |   4 +-
 .../src/main/java/org/tensorflow/Output.java  |   5 +-
 .../src/main/java/org/tensorflow/Tensor.java  |  28 +-
 .../src/main/java/org/tensorflow/Tensors.java |   2 +-
 .../internal/tensor/BooleanTensorImpl.java    |  96 ++++
 .../internal/tensor/ByteTensorImpl.java       |  95 ++++
 .../internal/tensor/DoubleTensorImpl.java     |  96 ++++
 .../internal/tensor/FloatTensorImpl.java      |  96 ++++
 .../internal/tensor/IntTensorImpl.java        |  96 ++++
 .../internal/tensor/LongTensorImpl.java       |  96 ++++
 .../{types => internal/tensor}/RawTensor.java |  20 +-
 .../tensor/StringTensorImpl.java}             |  58 +--
 .../buffer/ByteSequenceTensorBuffer.java      |   2 +-
 .../{ => tensor}/buffer/TensorBuffers.java    |   2 +-
 .../buffer/TensorRawDataBufferFactory.java    |   2 +-
 .../java/org/tensorflow/op/core/Constant.java | 164 +++----
 .../org/tensorflow/op/core/Gradients.java     |   5 +-
 .../java/org/tensorflow/op/core/Helpers.java  |   4 +-
 .../java/org/tensorflow/op/core/Shapes.java   |  40 +-
 .../java/org/tensorflow/op/core/Zeros.java    |   6 +-
 .../org/tensorflow/tensor/BooleanTensor.java  |  40 ++
 .../org/tensorflow/tensor/ByteTensor.java     |  39 ++
 .../org/tensorflow/tensor/DoubleTensor.java   |  40 ++
 .../org/tensorflow/tensor/FloatTensor.java    |  40 ++
 .../java/org/tensorflow/tensor/IntTensor.java |  40 ++
 .../org/tensorflow/tensor/LongTensor.java     |  40 ++
 .../org/tensorflow/tensor/StringTensor.java   |  29 ++
 .../org/tensorflow/types/BooleanTensor.java   | 126 ------
 .../java/org/tensorflow/types/ByteTensor.java | 125 -----
 .../org/tensorflow/types/DoubleTensor.java    | 126 ------
 .../org/tensorflow/types/FloatTensor.java     | 126 ------
 .../java/org/tensorflow/types/IntTensor.java  | 126 ------
 .../java/org/tensorflow/types/LongTensor.java | 126 ------
 .../java/org/tensorflow/types/TBfloat16.java  |  10 +-
 .../main/java/org/tensorflow/types/TBool.java |   8 +-
 .../java/org/tensorflow/types/TFloat16.java   |  10 +-
 .../java/org/tensorflow/types/TFloat32.java   |  10 +-
 .../java/org/tensorflow/types/TFloat64.java   |  10 +-
 .../java/org/tensorflow/types/TInt32.java     |   8 +-
 .../java/org/tensorflow/types/TInt64.java     |   8 +-
 .../java/org/tensorflow/types/TString.java    |  10 +-
 .../java/org/tensorflow/types/TUint8.java     |   8 +-
 .../tensorflow/types/family/TFloating.java    |   2 +-
 .../tensorflow/types/family/package-info.java |   3 -
 .../tensorflow/EagerOperationBuilderTest.java |   2 +-
 .../org/tensorflow/EagerOperationTest.java    |   4 +-
 .../tensorflow/GraphOperationBuilderTest.java |  10 +-
 .../test/java/org/tensorflow/GraphTest.java   |  36 +-
 .../test/java/org/tensorflow/SessionTest.java |  36 +-
 .../test/java/org/tensorflow/TensorTest.java  | 142 +++---
 .../java/org/tensorflow/op/ScopeTest.java     |  21 +-
 .../op/core/GeneratedOperationsTest.java      |  12 +-
 .../org/tensorflow/op/core/GradientsTest.java |  14 +-
 .../org/tensorflow/op/core/ShapesTest.java    | 104 ++---
 .../org/tensorflow/op/core/ZerosTest.java     |  28 +-
 .../types/NumericTypesTestBase.java           |  40 +-
 .../org/tensorflow/types/TBfloat16Test.java   |   2 +-
 .../org/tensorflow/types/TFloat16Test.java    |   2 +-
 .../org/tensorflow/types/TFloat32Test.java    |   2 +-
 .../org/tensorflow/types/TFloat64Test.java    |   2 +-
 .../java/org/tensorflow/types/TInt32Test.java |   2 +-
 .../java/org/tensorflow/types/TInt64Test.java |   2 +-
 .../org/tensorflow/types/TStringTest.java     |  41 +-
 .../java/org/tensorflow/types/TUint8Test.java |   2 +-
 941 files changed, 4738 insertions(+), 4644 deletions(-)
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java
 rename tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/{types => internal/tensor}/RawTensor.java (75%)
 rename tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/{types/StringTensor.java => internal/tensor/StringTensorImpl.java} (55%)
 rename tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/{ => tensor}/buffer/ByteSequenceTensorBuffer.java (99%)
 rename tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/{ => tensor}/buffer/TensorBuffers.java (99%)
 rename tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/{ => tensor}/buffer/TensorRawDataBufferFactory.java (98%)
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java
 create mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java
 delete mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java
 delete mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java
 delete mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java
 delete mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java
 delete mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java
 delete mode 100644 tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java

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 f0fb802d548..e5791dcc456 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
@@ -348,7 +348,7 @@ void RenderInterfaceImpl(const OpSpec& op, RenderMode mode,
   if (mode == OPERAND) {
     bool cast2obj = output.type().wildcard();
     Type return_type = Type::Class("Output", "org.tensorflow")
-        .add_parameter(cast2obj ? Type::Class("TType", "org.tensorflow.types.family") : output.type());
+        .add_parameter(cast2obj ? Type::Interface("Tensor", "org.tensorflow") : output.type());
     Method as_output = Method::Create("asOutput", return_type)
         .add_annotation(Annotation::Create("Override"));
     if (cast2obj) {
@@ -366,7 +366,7 @@ void RenderInterfaceImpl(const OpSpec& op, RenderMode mode,
   } else if (mode == LIST_OPERAND) {
     Type operand = Type::Interface("Operand", "org.tensorflow");
     if (output.type().wildcard()) {
-      operand.add_parameter(Type::Class("TType", "org.tensorflow.types.family"));
+      operand.add_parameter(Type::Interface("Tensor", "org.tensorflow"));
     } else {
       operand.add_parameter(output.type());
     }
@@ -430,10 +430,9 @@ void GenerateOp(const OpSpec& op, const EndpointSpec& endpoint,
   RenderMode mode = DEFAULT;
   if (op.outputs().size() == 1) {
     const ArgumentSpec& output = op.outputs().front();
-    Type operand_type(output.type().wildcard() ? Type::Class("TType", "org.tensorflow.types.family")
+    Type operand_type(output.type().wildcard() ? Type::Interface("Tensor", "org.tensorflow")
                                                : output.type());
-    Type operand_inf(Type::Interface("Operand", "org.tensorflow")
-                         .add_parameter(operand_type));
+    Type operand_inf(Type::Interface("Operand", "org.tensorflow").add_parameter(operand_type));
     if (output.iterable()) {
       mode = LIST_OPERAND;
       op_class.add_supertype(Type::IterableOf(operand_inf));
diff --git a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc
index c9e0525edb7..3c981bf8816 100644
--- a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc
+++ b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc
@@ -87,7 +87,7 @@ class TypeResolver {
       next_generic_letter_ = 'A';
     }
     return Type::Generic(string(1, generic_letter))
-        .add_supertype(Type::Class("TType", "org.tensorflow.types.family"));
+        .add_supertype(Type::Interface("Tensor", "org.tensorflow"));
   }
 };
 
@@ -158,7 +158,7 @@ std::pair<Type, Type> TypeResolver::TypesOf(const OpDef_AttrDef& attr_def,
   } else if (attr_type == "type") {
     Type type = *iterable_out ? Type::Wildcard() : NextGeneric();
     if (IsRealNumbers(attr_def.allowed_values())) {
-      type.add_supertype(Type::Class("TNumber", "org.tensorflow.types.family"));
+      type.add_supertype(Type::Interface("TNumber", "org.tensorflow.types.family"));
     }
     types = MakeTypePair(type, Type::Enum("DataType", "org.tensorflow"));
 
diff --git a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/source_writer.cc b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/source_writer.cc
index 63191c080ac..27185f1465b 100644
--- a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/source_writer.cc
+++ b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/source_writer.cc
@@ -305,8 +305,15 @@ SourceWriter& SourceWriter::WriteGenerics(
       Append(", ");
     }
     Append(pt->name());
-    if (!pt->supertypes().empty()) {
-      Append(" extends ").AppendType(pt->supertypes().front());
+    bool first_bound = true;
+    for (const Type& bound : pt->supertypes()) {
+      if (first_bound) {
+        Append(" extends ");
+        first_bound = false;
+      } else {
+        Append(" & ");
+      }
+      AppendType(bound);
     }
     first = false;
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java
index 8ac6d565e51..9cc4506b77a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java
@@ -18,6 +18,7 @@
 package org.tensorflow.op;
 
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.bitwise.BitwiseAnd;
 import org.tensorflow.op.bitwise.BitwiseOr;
 import org.tensorflow.op.bitwise.BitwiseXor;
@@ -65,7 +66,7 @@ public final class BitwiseOps {
    * @param y
    * @return a new instance of BitwiseAnd
    */
-  public <T extends TNumber> BitwiseAnd<T> bitwiseAnd(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> BitwiseAnd<T> bitwiseAnd(Operand<T> x, Operand<T> y) {
     return BitwiseAnd.create(scope, x, y);
   }
 
@@ -96,7 +97,7 @@ public <T extends TNumber> BitwiseAnd<T> bitwiseAnd(Operand<T> x, Operand<T> y)
    * @param y
    * @return a new instance of BitwiseOr
    */
-  public <T extends TNumber> BitwiseOr<T> bitwiseOr(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> BitwiseOr<T> bitwiseOr(Operand<T> x, Operand<T> y) {
     return BitwiseOr.create(scope, x, y);
   }
 
@@ -127,7 +128,7 @@ public <T extends TNumber> BitwiseOr<T> bitwiseOr(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of BitwiseXor
    */
-  public <T extends TNumber> BitwiseXor<T> bitwiseXor(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> BitwiseXor<T> bitwiseXor(Operand<T> x, Operand<T> y) {
     return BitwiseXor.create(scope, x, y);
   }
 
@@ -178,7 +179,7 @@ public <T extends TNumber> BitwiseXor<T> bitwiseXor(Operand<T> x, Operand<T> y)
    * @param x
    * @return a new instance of Invert
    */
-  public <T extends TNumber> Invert<T> invert(Operand<T> x) {
+  public <T extends Tensor & TNumber> Invert<T> invert(Operand<T> x) {
     return Invert.create(scope, x);
   }
 
@@ -220,7 +221,7 @@ public <T extends TNumber> Invert<T> invert(Operand<T> x) {
    * @param y
    * @return a new instance of LeftShift
    */
-  public <T extends TNumber> LeftShift<T> leftShift(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> LeftShift<T> leftShift(Operand<T> x, Operand<T> y) {
     return LeftShift.create(scope, x, y);
   }
 
@@ -265,7 +266,7 @@ public <T extends TNumber> LeftShift<T> leftShift(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of RightShift
    */
-  public <T extends TNumber> RightShift<T> rightShift(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> RightShift<T> rightShift(Operand<T> x, Operand<T> y) {
     return RightShift.create(scope, x, y);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java
index 16d571a6428..92f4466f181 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java
@@ -19,11 +19,11 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.dtypes.AsString;
 import org.tensorflow.op.dtypes.Cast;
 import org.tensorflow.op.dtypes.Complex;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code dtypes} operations as {@link Op Op}s
@@ -57,7 +57,7 @@ public final class DtypesOps {
    * @param options carries optional attributes values
    * @return a new instance of AsString
    */
-  public <T extends TType> AsString asString(Operand<T> input, AsString.Options... options) {
+  public <T extends Tensor> AsString asString(Operand<T> input, AsString.Options... options) {
     return AsString.create(scope, input, options);
   }
 
@@ -70,7 +70,7 @@ public <T extends TType> AsString asString(Operand<T> input, AsString.Options...
    * @param options carries optional attributes values
    * @return a new instance of Cast
    */
-  public <U extends TType, T extends TType> Cast<U> cast(Operand<T> x, DataType<U> DstT,
+  public <U extends Tensor, T extends Tensor> Cast<U> cast(Operand<T> x, DataType<U> DstT,
       Cast.Options... options) {
     return Cast.create(scope, x, DstT, options);
   }
@@ -98,8 +98,8 @@ public <U extends TType, T extends TType> Cast<U> cast(Operand<T> x, DataType<U>
    * @param Tout
    * @return a new instance of Complex
    */
-  public <U extends TType, T extends TNumber> Complex<U> complex(Operand<T> real, Operand<T> imag,
-      DataType<U> Tout) {
+  public <U extends Tensor, T extends Tensor & TNumber> Complex<U> complex(Operand<T> real,
+      Operand<T> imag, DataType<U> Tout) {
     return Complex.create(scope, real, imag, Tout);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java
index 9ea7a898d60..eddb078fdce 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java
@@ -20,6 +20,7 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.image.AdjustContrast;
 import org.tensorflow.op.image.AdjustHue;
 import org.tensorflow.op.image.AdjustSaturation;
@@ -57,7 +58,6 @@
 import org.tensorflow.types.TString;
 import org.tensorflow.types.TUint8;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code image} operations as {@link Op Op}s
@@ -89,7 +89,7 @@ public final class ImageOps {
    * @param contrastFactor A float multiplier for adjusting contrast.
    * @return a new instance of AdjustContrast
    */
-  public <T extends TNumber> AdjustContrast<T> adjustContrast(Operand<T> images,
+  public <T extends Tensor & TNumber> AdjustContrast<T> adjustContrast(Operand<T> images,
       Operand<TFloat32> contrastFactor) {
     return AdjustContrast.create(scope, images, contrastFactor);
   }
@@ -109,7 +109,8 @@ public <T extends TNumber> AdjustContrast<T> adjustContrast(Operand<T> images,
    * @param delta A float delta to add to the hue.
    * @return a new instance of AdjustHue
    */
-  public <T extends TNumber> AdjustHue<T> adjustHue(Operand<T> images, Operand<TFloat32> delta) {
+  public <T extends Tensor & TNumber> AdjustHue<T> adjustHue(Operand<T> images,
+      Operand<TFloat32> delta) {
     return AdjustHue.create(scope, images, delta);
   }
 
@@ -128,7 +129,7 @@ public <T extends TNumber> AdjustHue<T> adjustHue(Operand<T> images, Operand<TFl
    * @param scale A float scale to add to the saturation.
    * @return a new instance of AdjustSaturation
    */
-  public <T extends TNumber> AdjustSaturation<T> adjustSaturation(Operand<T> images,
+  public <T extends Tensor & TNumber> AdjustSaturation<T> adjustSaturation(Operand<T> images,
       Operand<TFloat32> scale) {
     return AdjustSaturation.create(scope, images, scale);
   }
@@ -212,8 +213,9 @@ public CombinedNonMaxSuppression combinedNonMaxSuppression(Operand<TFloat32> box
    * @param options carries optional attributes values
    * @return a new instance of CropAndResize
    */
-  public <T extends TNumber> CropAndResize cropAndResize(Operand<T> image, Operand<TFloat32> boxes,
-      Operand<TInt32> boxInd, Operand<TInt32> cropSize, CropAndResize.Options... options) {
+  public <T extends Tensor & TNumber> CropAndResize cropAndResize(Operand<T> image,
+      Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> cropSize,
+      CropAndResize.Options... options) {
     return CropAndResize.create(scope, image, boxes, boxInd, cropSize, options);
   }
 
@@ -238,8 +240,8 @@ public <T extends TNumber> CropAndResize cropAndResize(Operand<T> image, Operand
    * @param options carries optional attributes values
    * @return a new instance of CropAndResizeGradBoxes
    */
-  public <T extends TNumber> CropAndResizeGradBoxes cropAndResizeGradBoxes(Operand<TFloat32> grads,
-      Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd,
+  public <T extends Tensor & TNumber> CropAndResizeGradBoxes cropAndResizeGradBoxes(
+      Operand<TFloat32> grads, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd,
       CropAndResizeGradBoxes.Options... options) {
     return CropAndResizeGradBoxes.create(scope, grads, image, boxes, boxInd, options);
   }
@@ -268,7 +270,7 @@ public <T extends TNumber> CropAndResizeGradBoxes cropAndResizeGradBoxes(Operand
    * @param options carries optional attributes values
    * @return a new instance of CropAndResizeGradImage
    */
-  public <T extends TNumber> CropAndResizeGradImage<T> cropAndResizeGradImage(
+  public <T extends Tensor & TNumber> CropAndResizeGradImage<T> cropAndResizeGradImage(
       Operand<TFloat32> grads, Operand<TFloat32> boxes, Operand<TInt32> boxInd,
       Operand<TInt32> imageSize, DataType<T> T, CropAndResizeGradImage.Options... options) {
     return CropAndResizeGradImage.create(scope, grads, boxes, boxInd, imageSize, T, options);
@@ -461,8 +463,8 @@ public DecodePng<TUint8> decodePng(Operand<TString> contents, DecodePng.Options.
    * @param options carries optional attributes values
    * @return a new instance of DecodePng
    */
-  public <T extends TNumber> DecodePng<T> decodePng(Operand<TString> contents, DataType<T> dtype,
-      DecodePng.Options... options) {
+  public <T extends Tensor & TNumber> DecodePng<T> decodePng(Operand<TString> contents,
+      DataType<T> dtype, DecodePng.Options... options) {
     return DecodePng.create(scope, contents, dtype, options);
   }
 
@@ -488,7 +490,7 @@ public <T extends TNumber> DecodePng<T> decodePng(Operand<TString> contents, Dat
    * @param colors 2-D. A list of RGBA colors to cycle through for the boxes.
    * @return a new instance of DrawBoundingBoxes
    */
-  public <T extends TNumber> DrawBoundingBoxes<T> drawBoundingBoxes(Operand<T> images,
+  public <T extends Tensor & TNumber> DrawBoundingBoxes<T> drawBoundingBoxes(Operand<T> images,
       Operand<TFloat32> boxes, Operand<TFloat32> colors) {
     return DrawBoundingBoxes.create(scope, images, boxes, colors);
   }
@@ -572,7 +574,8 @@ public EncodeJpegVariableQuality encodeJpegVariableQuality(Operand<TUint8> image
    * @param options carries optional attributes values
    * @return a new instance of EncodePng
    */
-  public <T extends TNumber> EncodePng encodePng(Operand<T> image, EncodePng.Options... options) {
+  public <T extends Tensor & TNumber> EncodePng encodePng(Operand<T> image,
+      EncodePng.Options... options) {
     return EncodePng.create(scope, image, options);
   }
 
@@ -637,7 +640,7 @@ public ExtractGlimpse extractGlimpse(Operand<TFloat32> input, Operand<TInt32> si
    * @param padding The type of padding algorithm to use.
    * @return a new instance of ExtractImagePatches
    */
-  public <T extends TType> ExtractImagePatches<T> extractImagePatches(Operand<T> images,
+  public <T extends Tensor> ExtractImagePatches<T> extractImagePatches(Operand<T> images,
       List<Long> ksizes, List<Long> strides, List<Long> rates, String padding) {
     return ExtractImagePatches.create(scope, images, ksizes, strides, rates, padding);
   }
@@ -666,8 +669,8 @@ public ExtractJpegShape<TInt32> extractJpegShape(Operand<TString> contents) {
    *  Defaults to int32.
    * @return a new instance of ExtractJpegShape
    */
-  public <T extends TNumber> ExtractJpegShape<T> extractJpegShape(Operand<TString> contents,
-      DataType<T> outputType) {
+  public <T extends Tensor & TNumber> ExtractJpegShape<T> extractJpegShape(
+      Operand<TString> contents, DataType<T> outputType) {
     return ExtractJpegShape.create(scope, contents, outputType);
   }
 
@@ -684,7 +687,7 @@ public <T extends TNumber> ExtractJpegShape<T> extractJpegShape(Operand<TString>
    * @param images 1-D or higher rank. HSV data to convert. Last dimension must be size 3.
    * @return a new instance of HsvToRgb
    */
-  public <T extends TNumber> HsvToRgb<T> hsvToRgb(Operand<T> images) {
+  public <T extends Tensor & TNumber> HsvToRgb<T> hsvToRgb(Operand<T> images) {
     return HsvToRgb.create(scope, images);
   }
 
@@ -730,7 +733,7 @@ public <T extends TNumber> HsvToRgb<T> hsvToRgb(Operand<T> images) {
    * @param options carries optional attributes values
    * @return a new instance of NonMaxSuppression
    */
-  public <T extends TNumber> NonMaxSuppression<T> nonMaxSuppression(Operand<T> boxes,
+  public <T extends Tensor & TNumber> NonMaxSuppression<T> nonMaxSuppression(Operand<T> boxes,
       Operand<T> scores, Operand<TInt32> maxOutputSize, Operand<T> iouThreshold,
       Operand<T> scoreThreshold, Operand<T> softNmsSigma, NonMaxSuppression.Options... options) {
     return NonMaxSuppression.create(scope, boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, options);
@@ -786,7 +789,7 @@ public NonMaxSuppressionWithOverlaps nonMaxSuppressionWithOverlaps(Operand<TFloa
    * @param options carries optional attributes values
    * @return a new instance of QuantizedResizeBilinear
    */
-  public <T extends TType> QuantizedResizeBilinear<T> quantizedResizeBilinear(Operand<T> images,
+  public <T extends Tensor> QuantizedResizeBilinear<T> quantizedResizeBilinear(Operand<T> images,
       Operand<TInt32> size, Operand<TFloat32> min, Operand<TFloat32> max,
       QuantizedResizeBilinear.Options... options) {
     return QuantizedResizeBilinear.create(scope, images, size, min, max, options);
@@ -808,8 +811,8 @@ public <T extends TType> QuantizedResizeBilinear<T> quantizedResizeBilinear(Oper
    * @param options carries optional attributes values
    * @return a new instance of RandomCrop
    */
-  public <T extends TNumber> RandomCrop<T> randomCrop(Operand<T> image, Operand<TInt64> size,
-      RandomCrop.Options... options) {
+  public <T extends Tensor & TNumber> RandomCrop<T> randomCrop(Operand<T> image,
+      Operand<TInt64> size, RandomCrop.Options... options) {
     return RandomCrop.create(scope, image, size, options);
   }
 
@@ -834,7 +837,7 @@ public <T extends TNumber> RandomCrop<T> randomCrop(Operand<T> image, Operand<TI
    * @param options carries optional attributes values
    * @return a new instance of ResizeArea
    */
-  public <T extends TNumber> ResizeArea resizeArea(Operand<T> images, Operand<TInt32> size,
+  public <T extends Tensor & TNumber> ResizeArea resizeArea(Operand<T> images, Operand<TInt32> size,
       ResizeArea.Options... options) {
     return ResizeArea.create(scope, images, size, options);
   }
@@ -850,8 +853,8 @@ public <T extends TNumber> ResizeArea resizeArea(Operand<T> images, Operand<TInt
    * @param options carries optional attributes values
    * @return a new instance of ResizeBicubic
    */
-  public <T extends TNumber> ResizeBicubic resizeBicubic(Operand<T> images, Operand<TInt32> size,
-      ResizeBicubic.Options... options) {
+  public <T extends Tensor & TNumber> ResizeBicubic resizeBicubic(Operand<T> images,
+      Operand<TInt32> size, ResizeBicubic.Options... options) {
     return ResizeBicubic.create(scope, images, size, options);
   }
 
@@ -866,8 +869,8 @@ public <T extends TNumber> ResizeBicubic resizeBicubic(Operand<T> images, Operan
    * @param options carries optional attributes values
    * @return a new instance of ResizeBilinear
    */
-  public <T extends TNumber> ResizeBilinear resizeBilinear(Operand<T> images, Operand<TInt32> size,
-      ResizeBilinear.Options... options) {
+  public <T extends Tensor & TNumber> ResizeBilinear resizeBilinear(Operand<T> images,
+      Operand<TInt32> size, ResizeBilinear.Options... options) {
     return ResizeBilinear.create(scope, images, size, options);
   }
 
@@ -881,8 +884,8 @@ public <T extends TNumber> ResizeBilinear resizeBilinear(Operand<T> images, Oper
    * @param options carries optional attributes values
    * @return a new instance of ResizeNearestNeighbor
    */
-  public <T extends TNumber> ResizeNearestNeighbor<T> resizeNearestNeighbor(Operand<T> images,
-      Operand<TInt32> size, ResizeNearestNeighbor.Options... options) {
+  public <T extends Tensor & TNumber> ResizeNearestNeighbor<T> resizeNearestNeighbor(
+      Operand<T> images, Operand<TInt32> size, ResizeNearestNeighbor.Options... options) {
     return ResizeNearestNeighbor.create(scope, images, size, options);
   }
 
@@ -912,7 +915,7 @@ public <T extends TNumber> ResizeNearestNeighbor<T> resizeNearestNeighbor(Operan
    * @param images 1-D or higher rank. RGB data to convert. Last dimension must be size 3.
    * @return a new instance of RgbToHsv
    */
-  public <T extends TNumber> RgbToHsv<T> rgbToHsv(Operand<T> images) {
+  public <T extends Tensor & TNumber> RgbToHsv<T> rgbToHsv(Operand<T> images) {
     return RgbToHsv.create(scope, images);
   }
 
@@ -967,7 +970,7 @@ public <T extends TNumber> RgbToHsv<T> rgbToHsv(Operand<T> images) {
    * @param options carries optional attributes values
    * @return a new instance of SampleDistortedBoundingBox
    */
-  public <T extends TNumber> SampleDistortedBoundingBox<T> sampleDistortedBoundingBox(
+  public <T extends Tensor & TNumber> SampleDistortedBoundingBox<T> sampleDistortedBoundingBox(
       Operand<T> imageSize, Operand<TFloat32> boundingBoxes, Operand<TFloat32> minObjectCovered,
       SampleDistortedBoundingBox.Options... options) {
     return SampleDistortedBoundingBox.create(scope, imageSize, boundingBoxes, minObjectCovered, options);
@@ -982,7 +985,7 @@ public <T extends TNumber> SampleDistortedBoundingBox<T> sampleDistortedBounding
    * @param options carries optional attributes values
    * @return a new instance of ScaleAndTranslate
    */
-  public <T extends TNumber> ScaleAndTranslate scaleAndTranslate(Operand<T> images,
+  public <T extends Tensor & TNumber> ScaleAndTranslate scaleAndTranslate(Operand<T> images,
       Operand<TInt32> size, Operand<TFloat32> scale, Operand<TFloat32> translation,
       ScaleAndTranslate.Options... options) {
     return ScaleAndTranslate.create(scope, images, size, scale, translation, options);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java
index 872533472d9..e6e672fd266 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java
@@ -20,6 +20,7 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.io.DecodeBase64;
 import org.tensorflow.op.io.DecodeCompressed;
@@ -72,7 +73,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code io} operations as {@link Op Op}s
@@ -167,8 +167,9 @@ public DecodeJsonExample decodeJsonExample(Operand<TString> jsonExamples) {
    * @param options carries optional attributes values
    * @return a new instance of DecodePaddedRaw
    */
-  public <T extends TNumber> DecodePaddedRaw<T> decodePaddedRaw(Operand<TString> inputBytes,
-      Operand<TInt32> fixedLength, DataType<T> outType, DecodePaddedRaw.Options... options) {
+  public <T extends Tensor & TNumber> DecodePaddedRaw<T> decodePaddedRaw(
+      Operand<TString> inputBytes, Operand<TInt32> fixedLength, DataType<T> outType,
+      DecodePaddedRaw.Options... options) {
     return DecodePaddedRaw.create(scope, inputBytes, fixedLength, outType, options);
   }
 
@@ -181,7 +182,7 @@ public <T extends TNumber> DecodePaddedRaw<T> decodePaddedRaw(Operand<TString> i
    * @param options carries optional attributes values
    * @return a new instance of DecodeRaw
    */
-  public <T extends TType> DecodeRaw<T> decodeRaw(Operand<TString> bytes, DataType<T> outType,
+  public <T extends Tensor> DecodeRaw<T> decodeRaw(Operand<TString> bytes, DataType<T> outType,
       DecodeRaw.Options... options) {
     return DecodeRaw.create(scope, bytes, outType, options);
   }
@@ -237,7 +238,7 @@ public <T extends TType> DecodeRaw<T> decodeRaw(Operand<TString> bytes, DataType
    * @param dtype The `dtype` of the serialized `SparseTensor` objects.
    * @return a new instance of DeserializeManySparse
    */
-  public <T extends TType> DeserializeManySparse<T> deserializeManySparse(
+  public <T extends Tensor> DeserializeManySparse<T> deserializeManySparse(
       Operand<TString> serializedSparse, DataType<T> dtype) {
     return DeserializeManySparse.create(scope, serializedSparse, dtype);
   }
@@ -565,7 +566,7 @@ public ParseSingleSequenceExample parseSingleSequenceExample(Operand<TString> se
    *  type of the serialized tensor and no implicit conversion will take place.
    * @return a new instance of ParseTensor
    */
-  public <T extends TType> ParseTensor<T> parseTensor(Operand<TString> serialized,
+  public <T extends Tensor> ParseTensor<T> parseTensor(Operand<TString> serialized,
       DataType<T> outType) {
     return ParseTensor.create(scope, serialized, outType);
   }
@@ -888,7 +889,7 @@ public ReaderSerializeState readerSerializeState(Operand<?> readerHandle) {
    * @param sparseShape 1-D.  The `shape` of the minibatch `SparseTensor`.
    * @return a new instance of SerializeManySparse
    */
-  public <T extends TType> SerializeManySparse<TString> serializeManySparse(
+  public <T extends Tensor> SerializeManySparse<TString> serializeManySparse(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return SerializeManySparse.create(scope, sparseIndices, sparseValues, sparseShape);
   }
@@ -912,7 +913,7 @@ public <T extends TType> SerializeManySparse<TString> serializeManySparse(
    *  (default) and `variant`.
    * @return a new instance of SerializeManySparse
    */
-  public <U extends TType, T extends TType> SerializeManySparse<U> serializeManySparse(
+  public <U extends Tensor, T extends Tensor> SerializeManySparse<U> serializeManySparse(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       DataType<U> outType) {
     return SerializeManySparse.create(scope, sparseIndices, sparseValues, sparseShape, outType);
@@ -927,7 +928,7 @@ public <U extends TType, T extends TType> SerializeManySparse<U> serializeManySp
    * @param sparseShape 1-D.  The `shape` of the `SparseTensor`.
    * @return a new instance of SerializeSparse
    */
-  public <T extends TType> SerializeSparse<TString> serializeSparse(Operand<TInt64> sparseIndices,
+  public <T extends Tensor> SerializeSparse<TString> serializeSparse(Operand<TInt64> sparseIndices,
       Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return SerializeSparse.create(scope, sparseIndices, sparseValues, sparseShape);
   }
@@ -943,7 +944,7 @@ public <T extends TType> SerializeSparse<TString> serializeSparse(Operand<TInt64
    *  (default) and `variant`.
    * @return a new instance of SerializeSparse
    */
-  public <U extends TType, T extends TType> SerializeSparse<U> serializeSparse(
+  public <U extends Tensor, T extends Tensor> SerializeSparse<U> serializeSparse(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       DataType<U> outType) {
     return SerializeSparse.create(scope, sparseIndices, sparseValues, sparseShape, outType);
@@ -955,7 +956,7 @@ public <U extends TType, T extends TType> SerializeSparse<U> serializeSparse(
    * @param tensor A Tensor of type `T`.
    * @return a new instance of SerializeTensor
    */
-  public <T extends TType> SerializeTensor serializeTensor(Operand<T> tensor) {
+  public <T extends Tensor> SerializeTensor serializeTensor(Operand<T> tensor) {
     return SerializeTensor.create(scope, tensor);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java
index 9c82306e539..3b843bef341 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java
@@ -19,6 +19,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.linalg.BandPart;
 import org.tensorflow.op.linalg.BatchCholesky;
 import org.tensorflow.op.linalg.BatchCholeskyGrad;
@@ -68,7 +69,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code linalg} operations as {@link Op Op}s
@@ -130,7 +130,7 @@ public final class LinalgOps {
    *  entire upper triangle.
    * @return a new instance of BandPart
    */
-  public <T extends TType, U extends TNumber> BandPart<T> bandPart(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> BandPart<T> bandPart(Operand<T> input,
       Operand<U> numLower, Operand<U> numUpper) {
     return BandPart.create(scope, input, numLower, numUpper);
   }
@@ -141,7 +141,7 @@ public <T extends TType, U extends TNumber> BandPart<T> bandPart(Operand<T> inpu
    * @param input
    * @return a new instance of BatchCholesky
    */
-  public <T extends TNumber> BatchCholesky<T> batchCholesky(Operand<T> input) {
+  public <T extends Tensor & TNumber> BatchCholesky<T> batchCholesky(Operand<T> input) {
     return BatchCholesky.create(scope, input);
   }
 
@@ -152,7 +152,8 @@ public <T extends TNumber> BatchCholesky<T> batchCholesky(Operand<T> input) {
    * @param grad
    * @return a new instance of BatchCholeskyGrad
    */
-  public <T extends TNumber> BatchCholeskyGrad<T> batchCholeskyGrad(Operand<T> l, Operand<T> grad) {
+  public <T extends Tensor & TNumber> BatchCholeskyGrad<T> batchCholeskyGrad(Operand<T> l,
+      Operand<T> grad) {
     return BatchCholeskyGrad.create(scope, l, grad);
   }
 
@@ -164,7 +165,7 @@ public <T extends TNumber> BatchCholeskyGrad<T> batchCholeskyGrad(Operand<T> l,
    * @param numUpper
    * @return a new instance of BatchMatrixBandPart
    */
-  public <T extends TType> BatchMatrixBandPart<T> batchMatrixBandPart(Operand<T> input,
+  public <T extends Tensor> BatchMatrixBandPart<T> batchMatrixBandPart(Operand<T> input,
       Operand<TInt64> numLower, Operand<TInt64> numUpper) {
     return BatchMatrixBandPart.create(scope, input, numLower, numUpper);
   }
@@ -175,7 +176,7 @@ public <T extends TType> BatchMatrixBandPart<T> batchMatrixBandPart(Operand<T> i
    * @param input
    * @return a new instance of BatchMatrixDeterminant
    */
-  public <T extends TType> BatchMatrixDeterminant<T> batchMatrixDeterminant(Operand<T> input) {
+  public <T extends Tensor> BatchMatrixDeterminant<T> batchMatrixDeterminant(Operand<T> input) {
     return BatchMatrixDeterminant.create(scope, input);
   }
 
@@ -185,7 +186,7 @@ public <T extends TType> BatchMatrixDeterminant<T> batchMatrixDeterminant(Operan
    * @param diagonal
    * @return a new instance of BatchMatrixDiag
    */
-  public <T extends TType> BatchMatrixDiag<T> batchMatrixDiag(Operand<T> diagonal) {
+  public <T extends Tensor> BatchMatrixDiag<T> batchMatrixDiag(Operand<T> diagonal) {
     return BatchMatrixDiag.create(scope, diagonal);
   }
 
@@ -195,7 +196,7 @@ public <T extends TType> BatchMatrixDiag<T> batchMatrixDiag(Operand<T> diagonal)
    * @param input
    * @return a new instance of BatchMatrixDiagPart
    */
-  public <T extends TType> BatchMatrixDiagPart<T> batchMatrixDiagPart(Operand<T> input) {
+  public <T extends Tensor> BatchMatrixDiagPart<T> batchMatrixDiagPart(Operand<T> input) {
     return BatchMatrixDiagPart.create(scope, input);
   }
 
@@ -206,7 +207,7 @@ public <T extends TType> BatchMatrixDiagPart<T> batchMatrixDiagPart(Operand<T> i
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixInverse
    */
-  public <T extends TNumber> BatchMatrixInverse<T> batchMatrixInverse(Operand<T> input,
+  public <T extends Tensor & TNumber> BatchMatrixInverse<T> batchMatrixInverse(Operand<T> input,
       BatchMatrixInverse.Options... options) {
     return BatchMatrixInverse.create(scope, input, options);
   }
@@ -218,7 +219,7 @@ public <T extends TNumber> BatchMatrixInverse<T> batchMatrixInverse(Operand<T> i
    * @param diagonal
    * @return a new instance of BatchMatrixSetDiag
    */
-  public <T extends TType> BatchMatrixSetDiag<T> batchMatrixSetDiag(Operand<T> input,
+  public <T extends Tensor> BatchMatrixSetDiag<T> batchMatrixSetDiag(Operand<T> input,
       Operand<T> diagonal) {
     return BatchMatrixSetDiag.create(scope, input, diagonal);
   }
@@ -231,8 +232,8 @@ public <T extends TType> BatchMatrixSetDiag<T> batchMatrixSetDiag(Operand<T> inp
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixSolve
    */
-  public <T extends TNumber> BatchMatrixSolve<T> batchMatrixSolve(Operand<T> matrix, Operand<T> rhs,
-      BatchMatrixSolve.Options... options) {
+  public <T extends Tensor & TNumber> BatchMatrixSolve<T> batchMatrixSolve(Operand<T> matrix,
+      Operand<T> rhs, BatchMatrixSolve.Options... options) {
     return BatchMatrixSolve.create(scope, matrix, rhs, options);
   }
 
@@ -245,7 +246,7 @@ public <T extends TNumber> BatchMatrixSolve<T> batchMatrixSolve(Operand<T> matri
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixSolveLs
    */
-  public <T extends TNumber> BatchMatrixSolveLs<T> batchMatrixSolveLs(Operand<T> matrix,
+  public <T extends Tensor & TNumber> BatchMatrixSolveLs<T> batchMatrixSolveLs(Operand<T> matrix,
       Operand<T> rhs, Operand<TFloat64> l2Regularizer, BatchMatrixSolveLs.Options... options) {
     return BatchMatrixSolveLs.create(scope, matrix, rhs, l2Regularizer, options);
   }
@@ -258,7 +259,7 @@ public <T extends TNumber> BatchMatrixSolveLs<T> batchMatrixSolveLs(Operand<T> m
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixTriangularSolve
    */
-  public <T extends TNumber> BatchMatrixTriangularSolve<T> batchMatrixTriangularSolve(
+  public <T extends Tensor & TNumber> BatchMatrixTriangularSolve<T> batchMatrixTriangularSolve(
       Operand<T> matrix, Operand<T> rhs, BatchMatrixTriangularSolve.Options... options) {
     return BatchMatrixTriangularSolve.create(scope, matrix, rhs, options);
   }
@@ -270,7 +271,7 @@ public <T extends TNumber> BatchMatrixTriangularSolve<T> batchMatrixTriangularSo
    * @param options carries optional attributes values
    * @return a new instance of BatchSelfAdjointEig
    */
-  public <T extends TNumber> BatchSelfAdjointEig<T> batchSelfAdjointEig(Operand<T> input,
+  public <T extends Tensor & TNumber> BatchSelfAdjointEig<T> batchSelfAdjointEig(Operand<T> input,
       BatchSelfAdjointEig.Options... options) {
     return BatchSelfAdjointEig.create(scope, input, options);
   }
@@ -282,7 +283,7 @@ public <T extends TNumber> BatchSelfAdjointEig<T> batchSelfAdjointEig(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of BatchSvd
    */
-  public <T extends TType> BatchSvd<T> batchSvd(Operand<T> input, BatchSvd.Options... options) {
+  public <T extends Tensor> BatchSvd<T> batchSvd(Operand<T> input, BatchSvd.Options... options) {
     return BatchSvd.create(scope, input, options);
   }
 
@@ -307,7 +308,7 @@ public <T extends TType> BatchSvd<T> batchSvd(Operand<T> input, BatchSvd.Options
    * @param input Shape is `[..., M, M]`.
    * @return a new instance of Cholesky
    */
-  public <T extends TType> Cholesky<T> cholesky(Operand<T> input) {
+  public <T extends Tensor> Cholesky<T> cholesky(Operand<T> input) {
     return Cholesky.create(scope, input);
   }
 
@@ -326,7 +327,7 @@ public <T extends TType> Cholesky<T> cholesky(Operand<T> input) {
    *  this tensor.
    * @return a new instance of CholeskyGrad
    */
-  public <T extends TNumber> CholeskyGrad<T> choleskyGrad(Operand<T> l, Operand<T> grad) {
+  public <T extends Tensor & TNumber> CholeskyGrad<T> choleskyGrad(Operand<T> l, Operand<T> grad) {
     return CholeskyGrad.create(scope, l, grad);
   }
 
@@ -342,8 +343,8 @@ public <T extends TNumber> CholeskyGrad<T> choleskyGrad(Operand<T> l, Operand<T>
    * @param perm
    * @return a new instance of ConjugateTranspose
    */
-  public <T extends TType, U extends TNumber> ConjugateTranspose<T> conjugateTranspose(Operand<T> x,
-      Operand<U> perm) {
+  public <T extends Tensor, U extends Tensor & TNumber> ConjugateTranspose<T> conjugateTranspose(
+      Operand<T> x, Operand<U> perm) {
     return ConjugateTranspose.create(scope, x, perm);
   }
 
@@ -359,7 +360,7 @@ public <T extends TType, U extends TNumber> ConjugateTranspose<T> conjugateTrans
    * @param b Another tensor, of same type and shape as `a`.
    * @return a new instance of Cross
    */
-  public <T extends TNumber> Cross<T> cross(Operand<T> a, Operand<T> b) {
+  public <T extends Tensor & TNumber> Cross<T> cross(Operand<T> a, Operand<T> b) {
     return Cross.create(scope, a, b);
   }
 
@@ -374,7 +375,7 @@ public <T extends TNumber> Cross<T> cross(Operand<T> a, Operand<T> b) {
    * @param input Shape is `[..., M, M]`.
    * @return a new instance of Det
    */
-  public <T extends TType> Det<T> det(Operand<T> input) {
+  public <T extends Tensor> Det<T> det(Operand<T> input) {
     return Det.create(scope, input);
   }
 
@@ -398,7 +399,7 @@ public <T extends TType> Det<T> det(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of Eig
    */
-  public <U extends TType, T extends TType> Eig<U> eig(Operand<T> input, DataType<U> Tout,
+  public <U extends Tensor, T extends Tensor> Eig<U> eig(Operand<T> input, DataType<U> Tout,
       Eig.Options... options) {
     return Eig.create(scope, input, Tout, options);
   }
@@ -486,7 +487,7 @@ public <U extends TType, T extends TType> Eig<U> eig(Operand<T> input, DataType<
    * @param equation String describing the Einstein Summation operation; in the format of np.einsum.
    * @return a new instance of Einsum
    */
-  public <T extends TType> Einsum<T> einsum(Iterable<Operand<T>> inputs, String equation) {
+  public <T extends Tensor> Einsum<T> einsum(Iterable<Operand<T>> inputs, String equation) {
     return Einsum.create(scope, inputs, equation);
   }
 
@@ -505,8 +506,8 @@ public <T extends TType> Einsum<T> einsum(Iterable<Operand<T>> inputs, String eq
    * @param options carries optional attributes values
    * @return a new instance of EuclideanNorm
    */
-  public <T extends TType, U extends TNumber> EuclideanNorm<T> euclideanNorm(Operand<T> input,
-      Operand<U> axis, EuclideanNorm.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> EuclideanNorm<T> euclideanNorm(
+      Operand<T> input, Operand<U> axis, EuclideanNorm.Options... options) {
     return EuclideanNorm.create(scope, input, axis, options);
   }
 
@@ -530,7 +531,7 @@ public <T extends TType, U extends TNumber> EuclideanNorm<T> euclideanNorm(Opera
    * @param options carries optional attributes values
    * @return a new instance of Inv
    */
-  public <T extends TType> Inv<T> inv(Operand<T> input, Inv.Options... options) {
+  public <T extends Tensor> Inv<T> inv(Operand<T> input, Inv.Options... options) {
     return Inv.create(scope, input, options);
   }
 
@@ -620,7 +621,7 @@ public LoadAndRemapMatrix loadAndRemapMatrix(Operand<TString> ckptPath,
    * @param input Shape is `[N, M, M]`.
    * @return a new instance of LogMatrixDeterminant
    */
-  public <T extends TType> LogMatrixDeterminant<T> logMatrixDeterminant(Operand<T> input) {
+  public <T extends Tensor> LogMatrixDeterminant<T> logMatrixDeterminant(Operand<T> input) {
     return LogMatrixDeterminant.create(scope, input);
   }
 
@@ -651,7 +652,7 @@ public <T extends TType> LogMatrixDeterminant<T> logMatrixDeterminant(Operand<T>
    *  size `[M, M]`.
    * @return a new instance of Lu
    */
-  public <T extends TType> Lu<T, TInt32> lu(Operand<T> input) {
+  public <T extends Tensor> Lu<T, TInt32> lu(Operand<T> input) {
     return Lu.create(scope, input);
   }
 
@@ -683,7 +684,7 @@ public <T extends TType> Lu<T, TInt32> lu(Operand<T> input) {
    * @param outputIdxType
    * @return a new instance of Lu
    */
-  public <T extends TType, U extends TNumber> Lu<T, U> lu(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> Lu<T, U> lu(Operand<T> input,
       DataType<U> outputIdxType) {
     return Lu.create(scope, input, outputIdxType);
   }
@@ -705,7 +706,8 @@ public <T extends TType, U extends TNumber> Lu<T, U> lu(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of MatMul
    */
-  public <T extends TType> MatMul<T> matMul(Operand<T> a, Operand<T> b, MatMul.Options... options) {
+  public <T extends Tensor> MatMul<T> matMul(Operand<T> a, Operand<T> b,
+      MatMul.Options... options) {
     return MatMul.create(scope, a, b, options);
   }
 
@@ -812,7 +814,7 @@ public <T extends TType> MatMul<T> matMul(Operand<T> a, Operand<T> b, MatMul.Opt
    *  Default is 0.
    * @return a new instance of MatrixDiag
    */
-  public <T extends TType> MatrixDiag<T> matrixDiag(Operand<T> diagonal, Operand<TInt32> k,
+  public <T extends Tensor> MatrixDiag<T> matrixDiag(Operand<T> diagonal, Operand<TInt32> k,
       Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue) {
     return MatrixDiag.create(scope, diagonal, k, numRows, numCols, paddingValue);
   }
@@ -896,7 +898,7 @@ public <T extends TType> MatrixDiag<T> matrixDiag(Operand<T> diagonal, Operand<T
    *  Default is 0.
    * @return a new instance of MatrixDiagPart
    */
-  public <T extends TType> MatrixDiagPart<T> matrixDiagPart(Operand<T> input, Operand<TInt32> k,
+  public <T extends Tensor> MatrixDiagPart<T> matrixDiagPart(Operand<T> input, Operand<TInt32> k,
       Operand<T> paddingValue) {
     return MatrixDiagPart.create(scope, input, k, paddingValue);
   }
@@ -1012,8 +1014,8 @@ public <T extends TType> MatrixDiagPart<T> matrixDiagPart(Operand<T> input, Oper
    * @param options carries optional attributes values
    * @return a new instance of MatrixDiagPartV3
    */
-  public <T extends TType> MatrixDiagPartV3<T> matrixDiagPartV3(Operand<T> input, Operand<TInt32> k,
-      Operand<T> paddingValue, MatrixDiagPartV3.Options... options) {
+  public <T extends Tensor> MatrixDiagPartV3<T> matrixDiagPartV3(Operand<T> input,
+      Operand<TInt32> k, Operand<T> paddingValue, MatrixDiagPartV3.Options... options) {
     return MatrixDiagPartV3.create(scope, input, k, paddingValue, options);
   }
 
@@ -1150,7 +1152,7 @@ public <T extends TType> MatrixDiagPartV3<T> matrixDiagPartV3(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of MatrixDiagV3
    */
-  public <T extends TType> MatrixDiagV3<T> matrixDiagV3(Operand<T> diagonal, Operand<TInt32> k,
+  public <T extends Tensor> MatrixDiagV3<T> matrixDiagV3(Operand<T> diagonal, Operand<TInt32> k,
       Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue,
       MatrixDiagV3.Options... options) {
     return MatrixDiagV3.create(scope, diagonal, k, numRows, numCols, paddingValue, options);
@@ -1271,7 +1273,7 @@ public <T extends TType> MatrixDiagV3<T> matrixDiagV3(Operand<T> diagonal, Opera
    * @param options carries optional attributes values
    * @return a new instance of MatrixSetDiag
    */
-  public <T extends TType> MatrixSetDiag<T> matrixSetDiag(Operand<T> input, Operand<T> diagonal,
+  public <T extends Tensor> MatrixSetDiag<T> matrixSetDiag(Operand<T> input, Operand<T> diagonal,
       Operand<TInt32> k, MatrixSetDiag.Options... options) {
     return MatrixSetDiag.create(scope, input, diagonal, k, options);
   }
@@ -1324,7 +1326,7 @@ public <T extends TType> MatrixSetDiag<T> matrixSetDiag(Operand<T> input, Operan
    * @param options carries optional attributes values
    * @return a new instance of MatrixSolveLs
    */
-  public <T extends TType> MatrixSolveLs<T> matrixSolveLs(Operand<T> matrix, Operand<T> rhs,
+  public <T extends Tensor> MatrixSolveLs<T> matrixSolveLs(Operand<T> matrix, Operand<T> rhs,
       Operand<TFloat64> l2Regularizer, MatrixSolveLs.Options... options) {
     return MatrixSolveLs.create(scope, matrix, rhs, l2Regularizer, options);
   }
@@ -1348,7 +1350,7 @@ public <T extends TType> MatrixSolveLs<T> matrixSolveLs(Operand<T> matrix, Opera
    * @param options carries optional attributes values
    * @return a new instance of Qr
    */
-  public <T extends TType> Qr<T> qr(Operand<T> input, Qr.Options... options) {
+  public <T extends Tensor> Qr<T> qr(Operand<T> input, Qr.Options... options) {
     return Qr.create(scope, input, options);
   }
 
@@ -1373,7 +1375,7 @@ public <T extends TType> Qr<T> qr(Operand<T> input, Qr.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of QuantizedMatMul
    */
-  public <V extends TType, T extends TType, U extends TType, W extends TType> QuantizedMatMul<V> quantizedMatMul(
+  public <V extends Tensor, T extends Tensor, U extends Tensor, W extends Tensor> QuantizedMatMul<V> quantizedMatMul(
       Operand<T> a, Operand<U> b, Operand<TFloat32> minA, Operand<TFloat32> maxA,
       Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, DataType<W> Tactivation,
       QuantizedMatMul.Options... options) {
@@ -1399,7 +1401,7 @@ public <V extends TType, T extends TType, U extends TType, W extends TType> Quan
    * @param options carries optional attributes values
    * @return a new instance of SelfAdjointEig
    */
-  public <T extends TType> SelfAdjointEig<T> selfAdjointEig(Operand<T> input,
+  public <T extends Tensor> SelfAdjointEig<T> selfAdjointEig(Operand<T> input,
       SelfAdjointEig.Options... options) {
     return SelfAdjointEig.create(scope, input, options);
   }
@@ -1420,7 +1422,7 @@ public <T extends TType> SelfAdjointEig<T> selfAdjointEig(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of Solve
    */
-  public <T extends TType> Solve<T> solve(Operand<T> matrix, Operand<T> rhs,
+  public <T extends Tensor> Solve<T> solve(Operand<T> matrix, Operand<T> rhs,
       Solve.Options... options) {
     return Solve.create(scope, matrix, rhs, options);
   }
@@ -1448,7 +1450,7 @@ public <T extends TType> Solve<T> solve(Operand<T> matrix, Operand<T> rhs,
    * @param input Shape is `[..., M, M]`.
    * @return a new instance of Sqrtm
    */
-  public <T extends TType> Sqrtm<T> sqrtm(Operand<T> input) {
+  public <T extends Tensor> Sqrtm<T> sqrtm(Operand<T> input) {
     return Sqrtm.create(scope, input);
   }
 
@@ -1472,7 +1474,7 @@ public <T extends TType> Sqrtm<T> sqrtm(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of Svd
    */
-  public <T extends TType> Svd<T> svd(Operand<T> input, Svd.Options... options) {
+  public <T extends Tensor> Svd<T> svd(Operand<T> input, Svd.Options... options) {
     return Svd.create(scope, input, options);
   }
 
@@ -1500,7 +1502,7 @@ public <T extends TType> Svd<T> svd(Operand<T> input, Svd.Options... options) {
    * @param diagonal Rank k tensor where k is at most 1.
    * @return a new instance of TensorDiag
    */
-  public <T extends TType> TensorDiag<T> tensorDiag(Operand<T> diagonal) {
+  public <T extends Tensor> TensorDiag<T> tensorDiag(Operand<T> diagonal) {
     return TensorDiag.create(scope, diagonal);
   }
 
@@ -1529,7 +1531,7 @@ public <T extends TType> TensorDiag<T> tensorDiag(Operand<T> diagonal) {
    * @param input Rank k tensor where k is even and not zero.
    * @return a new instance of TensorDiagPart
    */
-  public <T extends TType> TensorDiagPart<T> tensorDiagPart(Operand<T> input) {
+  public <T extends Tensor> TensorDiagPart<T> tensorDiagPart(Operand<T> input) {
     return TensorDiagPart.create(scope, input);
   }
 
@@ -1544,7 +1546,7 @@ public <T extends TType> TensorDiagPart<T> tensorDiagPart(Operand<T> input) {
    * @param perm
    * @return a new instance of Transpose
    */
-  public <T extends TType, U extends TNumber> Transpose<T> transpose(Operand<T> x,
+  public <T extends Tensor, U extends Tensor & TNumber> Transpose<T> transpose(Operand<T> x,
       Operand<U> perm) {
     return Transpose.create(scope, x, perm);
   }
@@ -1604,7 +1606,7 @@ public <T extends TType, U extends TNumber> Transpose<T> transpose(Operand<T> x,
    * @param options carries optional attributes values
    * @return a new instance of TriangularSolve
    */
-  public <T extends TType> TriangularSolve<T> triangularSolve(Operand<T> matrix, Operand<T> rhs,
+  public <T extends Tensor> TriangularSolve<T> triangularSolve(Operand<T> matrix, Operand<T> rhs,
       TriangularSolve.Options... options) {
     return TriangularSolve.create(scope, matrix, rhs, options);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java
index 8da2c9ee3cd..3c983272e6d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java
@@ -19,6 +19,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.math.Abs;
 import org.tensorflow.op.math.AccumulateN;
@@ -129,7 +130,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code math} operations as {@link Op Op}s
@@ -154,7 +154,7 @@ public final class MathOps {
    * @param x
    * @return a new instance of Abs
    */
-  public <T extends TNumber> Abs<T> abs(Operand<T> x) {
+  public <T extends Tensor & TNumber> Abs<T> abs(Operand<T> x) {
     return Abs.create(scope, x);
   }
 
@@ -175,7 +175,7 @@ public <T extends TNumber> Abs<T> abs(Operand<T> x) {
    * @param shape Shape of elements of `inputs`.
    * @return a new instance of AccumulateN
    */
-  public <T extends TType> AccumulateN<T> accumulateN(Iterable<Operand<T>> inputs, Shape shape) {
+  public <T extends Tensor> AccumulateN<T> accumulateN(Iterable<Operand<T>> inputs, Shape shape) {
     return AccumulateN.create(scope, inputs, shape);
   }
 
@@ -186,7 +186,7 @@ public <T extends TType> AccumulateN<T> accumulateN(Iterable<Operand<T>> inputs,
    * @param x
    * @return a new instance of Acos
    */
-  public <T extends TType> Acos<T> acos(Operand<T> x) {
+  public <T extends Tensor> Acos<T> acos(Operand<T> x) {
     return Acos.create(scope, x);
   }
 
@@ -204,7 +204,7 @@ public <T extends TType> Acos<T> acos(Operand<T> x) {
    * @param x
    * @return a new instance of Acosh
    */
-  public <T extends TType> Acosh<T> acosh(Operand<T> x) {
+  public <T extends Tensor> Acosh<T> acosh(Operand<T> x) {
     return Acosh.create(scope, x);
   }
 
@@ -219,7 +219,7 @@ public <T extends TType> Acosh<T> acosh(Operand<T> x) {
    * @param y
    * @return a new instance of Add
    */
-  public <T extends TType> Add<T> add(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Add<T> add(Operand<T> x, Operand<T> y) {
     return Add.create(scope, x, y);
   }
 
@@ -237,7 +237,7 @@ public <T extends TType> Add<T> add(Operand<T> x, Operand<T> y) {
    * @param inputs
    * @return a new instance of AddN
    */
-  public <T extends TType> AddN<T> addN(Iterable<Operand<T>> inputs) {
+  public <T extends Tensor> AddN<T> addN(Iterable<Operand<T>> inputs) {
     return AddN.create(scope, inputs);
   }
 
@@ -263,7 +263,7 @@ public <T extends TType> AddN<T> addN(Iterable<Operand<T>> inputs) {
    * @param input
    * @return a new instance of Angle
    */
-  public <T extends TType> Angle<TFloat32> angle(Operand<T> input) {
+  public <T extends Tensor> Angle<TFloat32> angle(Operand<T> input) {
     return Angle.create(scope, input);
   }
 
@@ -290,7 +290,8 @@ public <T extends TType> Angle<TFloat32> angle(Operand<T> input) {
    * @param Tout
    * @return a new instance of Angle
    */
-  public <U extends TNumber, T extends TType> Angle<U> angle(Operand<T> input, DataType<U> Tout) {
+  public <U extends Tensor & TNumber, T extends Tensor> Angle<U> angle(Operand<T> input,
+      DataType<U> Tout) {
     return Angle.create(scope, input, Tout);
   }
 
@@ -302,7 +303,7 @@ public <U extends TNumber, T extends TType> Angle<U> angle(Operand<T> input, Dat
    * @param options carries optional attributes values
    * @return a new instance of ApproximateEqual
    */
-  public <T extends TType> ApproximateEqual approximateEqual(Operand<T> x, Operand<T> y,
+  public <T extends Tensor> ApproximateEqual approximateEqual(Operand<T> x, Operand<T> y,
       ApproximateEqual.Options... options) {
     return ApproximateEqual.create(scope, x, y, options);
   }
@@ -329,7 +330,7 @@ public <T extends TType> ApproximateEqual approximateEqual(Operand<T> x, Operand
    *  use dimension = 0.
    * @return a new instance of ArgMax
    */
-  public <T extends TType, U extends TNumber> ArgMax<TInt64> argMax(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> ArgMax<TInt64> argMax(Operand<T> input,
       Operand<U> dimension) {
     return ArgMax.create(scope, input, dimension);
   }
@@ -357,8 +358,8 @@ public <T extends TType, U extends TNumber> ArgMax<TInt64> argMax(Operand<T> inp
    * @param outputType
    * @return a new instance of ArgMax
    */
-  public <V extends TNumber, T extends TType, U extends TNumber> ArgMax<V> argMax(Operand<T> input,
-      Operand<U> dimension, DataType<V> outputType) {
+  public <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMax<V> argMax(
+      Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
     return ArgMax.create(scope, input, dimension, outputType);
   }
 
@@ -384,7 +385,7 @@ public <V extends TNumber, T extends TType, U extends TNumber> ArgMax<V> argMax(
    *  use dimension = 0.
    * @return a new instance of ArgMin
    */
-  public <T extends TType, U extends TNumber> ArgMin<TInt64> argMin(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> ArgMin<TInt64> argMin(Operand<T> input,
       Operand<U> dimension) {
     return ArgMin.create(scope, input, dimension);
   }
@@ -412,8 +413,8 @@ public <T extends TType, U extends TNumber> ArgMin<TInt64> argMin(Operand<T> inp
    * @param outputType
    * @return a new instance of ArgMin
    */
-  public <V extends TNumber, T extends TType, U extends TNumber> ArgMin<V> argMin(Operand<T> input,
-      Operand<U> dimension, DataType<V> outputType) {
+  public <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMin<V> argMin(
+      Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
     return ArgMin.create(scope, input, dimension, outputType);
   }
 
@@ -439,7 +440,7 @@ public <V extends TNumber, T extends TType, U extends TNumber> ArgMin<V> argMin(
    * @param x
    * @return a new instance of Asin
    */
-  public <T extends TType> Asin<T> asin(Operand<T> x) {
+  public <T extends Tensor> Asin<T> asin(Operand<T> x) {
     return Asin.create(scope, x);
   }
 
@@ -459,7 +460,7 @@ public <T extends TType> Asin<T> asin(Operand<T> x) {
    * @param x
    * @return a new instance of Asinh
    */
-  public <T extends TType> Asinh<T> asinh(Operand<T> x) {
+  public <T extends Tensor> Asinh<T> asinh(Operand<T> x) {
     return Asinh.create(scope, x);
   }
 
@@ -485,7 +486,7 @@ public <T extends TType> Asinh<T> asinh(Operand<T> x) {
    * @param x
    * @return a new instance of Atan
    */
-  public <T extends TType> Atan<T> atan(Operand<T> x) {
+  public <T extends Tensor> Atan<T> atan(Operand<T> x) {
     return Atan.create(scope, x);
   }
 
@@ -503,7 +504,7 @@ public <T extends TType> Atan<T> atan(Operand<T> x) {
    * @param x
    * @return a new instance of Atan2
    */
-  public <T extends TNumber> Atan2<T> atan2(Operand<T> y, Operand<T> x) {
+  public <T extends Tensor & TNumber> Atan2<T> atan2(Operand<T> y, Operand<T> x) {
     return Atan2.create(scope, y, x);
   }
 
@@ -525,7 +526,7 @@ public <T extends TNumber> Atan2<T> atan2(Operand<T> y, Operand<T> x) {
    * @param x
    * @return a new instance of Atanh
    */
-  public <T extends TType> Atanh<T> atanh(Operand<T> x) {
+  public <T extends Tensor> Atanh<T> atanh(Operand<T> x) {
     return Atanh.create(scope, x);
   }
 
@@ -541,7 +542,7 @@ public <T extends TType> Atanh<T> atanh(Operand<T> x) {
    * @param x
    * @return a new instance of BesselI0e
    */
-  public <T extends TNumber> BesselI0e<T> besselI0e(Operand<T> x) {
+  public <T extends Tensor & TNumber> BesselI0e<T> besselI0e(Operand<T> x) {
     return BesselI0e.create(scope, x);
   }
 
@@ -557,7 +558,7 @@ public <T extends TNumber> BesselI0e<T> besselI0e(Operand<T> x) {
    * @param x
    * @return a new instance of BesselI1e
    */
-  public <T extends TNumber> BesselI1e<T> besselI1e(Operand<T> x) {
+  public <T extends Tensor & TNumber> BesselI1e<T> besselI1e(Operand<T> x) {
     return BesselI1e.create(scope, x);
   }
 
@@ -581,7 +582,7 @@ public <T extends TNumber> BesselI1e<T> besselI1e(Operand<T> x) {
    * @param x
    * @return a new instance of Betainc
    */
-  public <T extends TNumber> Betainc<T> betainc(Operand<T> a, Operand<T> b, Operand<T> x) {
+  public <T extends Tensor & TNumber> Betainc<T> betainc(Operand<T> a, Operand<T> b, Operand<T> x) {
     return Betainc.create(scope, a, b, x);
   }
 
@@ -604,8 +605,8 @@ public <T extends TNumber> Betainc<T> betainc(Operand<T> a, Operand<T> b, Operan
    *  equal to 1.
    * @return a new instance of Bincount
    */
-  public <T extends TNumber> Bincount<T> bincount(Operand<TInt32> arr, Operand<TInt32> size,
-      Operand<T> weights) {
+  public <T extends Tensor & TNumber> Bincount<T> bincount(Operand<TInt32> arr,
+      Operand<TInt32> size, Operand<T> weights) {
     return Bincount.create(scope, arr, size, weights);
   }
 
@@ -616,7 +617,7 @@ public <T extends TNumber> Bincount<T> bincount(Operand<TInt32> arr, Operand<TIn
    * @param x
    * @return a new instance of Ceil
    */
-  public <T extends TNumber> Ceil<T> ceil(Operand<T> x) {
+  public <T extends Tensor & TNumber> Ceil<T> ceil(Operand<T> x) {
     return Ceil.create(scope, x);
   }
 
@@ -649,7 +650,7 @@ public <T extends TNumber> Ceil<T> ceil(Operand<T> x) {
    * @param threshold Threshold to compare against.
    * @return a new instance of CompareAndBitpack
    */
-  public <T extends TType> CompareAndBitpack compareAndBitpack(Operand<T> input,
+  public <T extends Tensor> CompareAndBitpack compareAndBitpack(Operand<T> input,
       Operand<T> threshold) {
     return CompareAndBitpack.create(scope, input, threshold);
   }
@@ -666,7 +667,7 @@ public <T extends TType> CompareAndBitpack compareAndBitpack(Operand<T> input,
    * @param x
    * @return a new instance of ComplexAbs
    */
-  public <T extends TType> ComplexAbs<TFloat32> complexAbs(Operand<T> x) {
+  public <T extends Tensor> ComplexAbs<TFloat32> complexAbs(Operand<T> x) {
     return ComplexAbs.create(scope, x);
   }
 
@@ -683,7 +684,7 @@ public <T extends TType> ComplexAbs<TFloat32> complexAbs(Operand<T> x) {
    * @param Tout
    * @return a new instance of ComplexAbs
    */
-  public <U extends TNumber, T extends TType> ComplexAbs<U> complexAbs(Operand<T> x,
+  public <U extends Tensor & TNumber, T extends Tensor> ComplexAbs<U> complexAbs(Operand<T> x,
       DataType<U> Tout) {
     return ComplexAbs.create(scope, x, Tout);
   }
@@ -708,7 +709,7 @@ public <U extends TNumber, T extends TType> ComplexAbs<U> complexAbs(Operand<T>
    * @param input
    * @return a new instance of Conj
    */
-  public <T extends TType> Conj<T> conj(Operand<T> input) {
+  public <T extends Tensor> Conj<T> conj(Operand<T> input) {
     return Conj.create(scope, input);
   }
 
@@ -729,7 +730,7 @@ public <T extends TType> Conj<T> conj(Operand<T> input) {
    * @param x
    * @return a new instance of Cos
    */
-  public <T extends TType> Cos<T> cos(Operand<T> x) {
+  public <T extends Tensor> Cos<T> cos(Operand<T> x) {
     return Cos.create(scope, x);
   }
 
@@ -749,7 +750,7 @@ public <T extends TType> Cos<T> cos(Operand<T> x) {
    * @param x
    * @return a new instance of Cosh
    */
-  public <T extends TType> Cosh<T> cosh(Operand<T> x) {
+  public <T extends Tensor> Cosh<T> cosh(Operand<T> x) {
     return Cosh.create(scope, x);
   }
 
@@ -787,8 +788,8 @@ public <T extends TType> Cosh<T> cosh(Operand<T> x) {
    * @param options carries optional attributes values
    * @return a new instance of Cumprod
    */
-  public <T extends TType, U extends TNumber> Cumprod<T> cumprod(Operand<T> x, Operand<U> axis,
-      Cumprod.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> Cumprod<T> cumprod(Operand<T> x,
+      Operand<U> axis, Cumprod.Options... options) {
     return Cumprod.create(scope, x, axis, options);
   }
 
@@ -826,8 +827,8 @@ public <T extends TType, U extends TNumber> Cumprod<T> cumprod(Operand<T> x, Ope
    * @param options carries optional attributes values
    * @return a new instance of Cumsum
    */
-  public <T extends TType, U extends TNumber> Cumsum<T> cumsum(Operand<T> x, Operand<U> axis,
-      Cumsum.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> Cumsum<T> cumsum(Operand<T> x,
+      Operand<U> axis, Cumsum.Options... options) {
     return Cumsum.create(scope, x, axis, options);
   }
 
@@ -840,7 +841,7 @@ public <T extends TType, U extends TNumber> Cumsum<T> cumsum(Operand<T> x, Opera
    * @param x
    * @return a new instance of Digamma
    */
-  public <T extends TNumber> Digamma<T> digamma(Operand<T> x) {
+  public <T extends Tensor & TNumber> Digamma<T> digamma(Operand<T> x) {
     return Digamma.create(scope, x);
   }
 
@@ -855,7 +856,7 @@ public <T extends TNumber> Digamma<T> digamma(Operand<T> x) {
    * @param y
    * @return a new instance of Div
    */
-  public <T extends TType> Div<T> div(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Div<T> div(Operand<T> x, Operand<T> y) {
     return Div.create(scope, x, y);
   }
 
@@ -871,7 +872,7 @@ public <T extends TType> Div<T> div(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of DivNoNan
    */
-  public <T extends TType> DivNoNan<T> divNoNan(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> DivNoNan<T> divNoNan(Operand<T> x, Operand<T> y) {
     return DivNoNan.create(scope, x, y);
   }
 
@@ -895,7 +896,7 @@ public <T extends TType> DivNoNan<T> divNoNan(Operand<T> x, Operand<T> y) {
    * @param options carries optional attributes values
    * @return a new instance of Equal
    */
-  public <T extends TType> Equal equal(Operand<T> x, Operand<T> y, Equal.Options... options) {
+  public <T extends Tensor> Equal equal(Operand<T> x, Operand<T> y, Equal.Options... options) {
     return Equal.create(scope, x, y, options);
   }
 
@@ -906,7 +907,7 @@ public <T extends TType> Equal equal(Operand<T> x, Operand<T> y, Equal.Options..
    * @param x
    * @return a new instance of Erf
    */
-  public <T extends TNumber> Erf<T> erf(Operand<T> x) {
+  public <T extends Tensor & TNumber> Erf<T> erf(Operand<T> x) {
     return Erf.create(scope, x);
   }
 
@@ -917,7 +918,7 @@ public <T extends TNumber> Erf<T> erf(Operand<T> x) {
    * @param x
    * @return a new instance of Erfc
    */
-  public <T extends TNumber> Erfc<T> erfc(Operand<T> x) {
+  public <T extends Tensor & TNumber> Erfc<T> erfc(Operand<T> x) {
     return Erfc.create(scope, x);
   }
 
@@ -927,7 +928,7 @@ public <T extends TNumber> Erfc<T> erfc(Operand<T> x) {
    * @param x
    * @return a new instance of erfinv
    */
-  public <T extends TNumber> erfinv<T> erfinv(Operand<T> x) {
+  public <T extends Tensor & TNumber> erfinv<T> erfinv(Operand<T> x) {
     return erfinv.create(scope, x);
   }
 
@@ -963,7 +964,7 @@ public <T extends TNumber> erfinv<T> erfinv(Operand<T> x) {
    * @param x
    * @return a new instance of Exp
    */
-  public <T extends TType> Exp<T> exp(Operand<T> x) {
+  public <T extends Tensor> Exp<T> exp(Operand<T> x) {
     return Exp.create(scope, x);
   }
 
@@ -988,7 +989,7 @@ public <T extends TType> Exp<T> exp(Operand<T> x) {
    * @param x
    * @return a new instance of Expm1
    */
-  public <T extends TType> Expm1<T> expm1(Operand<T> x) {
+  public <T extends Tensor> Expm1<T> expm1(Operand<T> x) {
     return Expm1.create(scope, x);
   }
 
@@ -1008,7 +1009,7 @@ public Fact fact() {
    * @param x
    * @return a new instance of Floor
    */
-  public <T extends TNumber> Floor<T> floor(Operand<T> x) {
+  public <T extends Tensor & TNumber> Floor<T> floor(Operand<T> x) {
     return Floor.create(scope, x);
   }
 
@@ -1023,7 +1024,7 @@ public <T extends TNumber> Floor<T> floor(Operand<T> x) {
    * @param y
    * @return a new instance of FloorDiv
    */
-  public <T extends TType> FloorDiv<T> floorDiv(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> FloorDiv<T> floorDiv(Operand<T> x, Operand<T> y) {
     return FloorDiv.create(scope, x, y);
   }
 
@@ -1041,7 +1042,7 @@ public <T extends TType> FloorDiv<T> floorDiv(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of FloorMod
    */
-  public <T extends TNumber> FloorMod<T> floorMod(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> FloorMod<T> floorMod(Operand<T> x, Operand<T> y) {
     return FloorMod.create(scope, x, y);
   }
 
@@ -1066,7 +1067,7 @@ public <T extends TNumber> FloorMod<T> floorMod(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Greater
    */
-  public <T extends TNumber> Greater greater(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> Greater greater(Operand<T> x, Operand<T> y) {
     return Greater.create(scope, x, y);
   }
 
@@ -1091,7 +1092,7 @@ public <T extends TNumber> Greater greater(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of GreaterEqual
    */
-  public <T extends TNumber> GreaterEqual greaterEqual(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> GreaterEqual greaterEqual(Operand<T> x, Operand<T> y) {
     return GreaterEqual.create(scope, x, y);
   }
 
@@ -1116,7 +1117,7 @@ public <T extends TNumber> GreaterEqual greaterEqual(Operand<T> x, Operand<T> y)
    * @param x
    * @return a new instance of Igamma
    */
-  public <T extends TNumber> Igamma<T> igamma(Operand<T> a, Operand<T> x) {
+  public <T extends Tensor & TNumber> Igamma<T> igamma(Operand<T> a, Operand<T> x) {
     return Igamma.create(scope, a, x);
   }
 
@@ -1141,7 +1142,7 @@ public <T extends TNumber> Igamma<T> igamma(Operand<T> a, Operand<T> x) {
    * @param x
    * @return a new instance of Igammac
    */
-  public <T extends TNumber> Igammac<T> igammac(Operand<T> a, Operand<T> x) {
+  public <T extends Tensor & TNumber> Igammac<T> igammac(Operand<T> a, Operand<T> x) {
     return Igammac.create(scope, a, x);
   }
 
@@ -1163,7 +1164,7 @@ public <T extends TNumber> Igammac<T> igammac(Operand<T> a, Operand<T> x) {
    * @param input
    * @return a new instance of Imag
    */
-  public <T extends TType> Imag<TFloat32> imag(Operand<T> input) {
+  public <T extends Tensor> Imag<TFloat32> imag(Operand<T> input) {
     return Imag.create(scope, input);
   }
 
@@ -1186,7 +1187,8 @@ public <T extends TType> Imag<TFloat32> imag(Operand<T> input) {
    * @param Tout
    * @return a new instance of Imag
    */
-  public <U extends TNumber, T extends TType> Imag<U> imag(Operand<T> input, DataType<U> Tout) {
+  public <U extends Tensor & TNumber, T extends Tensor> Imag<U> imag(Operand<T> input,
+      DataType<U> Tout) {
     return Imag.create(scope, input, Tout);
   }
 
@@ -1212,7 +1214,7 @@ public <U extends TNumber, T extends TType> Imag<U> imag(Operand<T> input, DataT
    * @param x 1-D.
    * @return a new instance of InvertPermutation
    */
-  public <T extends TNumber> InvertPermutation<T> invertPermutation(Operand<T> x) {
+  public <T extends Tensor & TNumber> InvertPermutation<T> invertPermutation(Operand<T> x) {
     return InvertPermutation.create(scope, x);
   }
 
@@ -1230,7 +1232,7 @@ public <T extends TNumber> InvertPermutation<T> invertPermutation(Operand<T> x)
    * @param x
    * @return a new instance of IsFinite
    */
-  public <T extends TNumber> IsFinite isFinite(Operand<T> x) {
+  public <T extends Tensor & TNumber> IsFinite isFinite(Operand<T> x) {
     return IsFinite.create(scope, x);
   }
 
@@ -1248,7 +1250,7 @@ public <T extends TNumber> IsFinite isFinite(Operand<T> x) {
    * @param x
    * @return a new instance of IsInf
    */
-  public <T extends TNumber> IsInf isInf(Operand<T> x) {
+  public <T extends Tensor & TNumber> IsInf isInf(Operand<T> x) {
     return IsInf.create(scope, x);
   }
 
@@ -1266,7 +1268,7 @@ public <T extends TNumber> IsInf isInf(Operand<T> x) {
    * @param x
    * @return a new instance of IsNan
    */
-  public <T extends TNumber> IsNan isNan(Operand<T> x) {
+  public <T extends Tensor & TNumber> IsNan isNan(Operand<T> x) {
     return IsNan.create(scope, x);
   }
 
@@ -1291,7 +1293,7 @@ public <T extends TNumber> IsNan isNan(Operand<T> x) {
    * @param y
    * @return a new instance of Less
    */
-  public <T extends TNumber> Less less(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> Less less(Operand<T> x, Operand<T> y) {
     return Less.create(scope, x, y);
   }
 
@@ -1316,7 +1318,7 @@ public <T extends TNumber> Less less(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of LessEqual
    */
-  public <T extends TNumber> LessEqual lessEqual(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> LessEqual lessEqual(Operand<T> x, Operand<T> y) {
     return LessEqual.create(scope, x, y);
   }
 
@@ -1336,7 +1338,7 @@ public <T extends TNumber> LessEqual lessEqual(Operand<T> x, Operand<T> y) {
    * @param x
    * @return a new instance of Lgamma
    */
-  public <T extends TNumber> Lgamma<T> lgamma(Operand<T> x) {
+  public <T extends Tensor & TNumber> Lgamma<T> lgamma(Operand<T> x) {
     return Lgamma.create(scope, x);
   }
 
@@ -1355,7 +1357,7 @@ public <T extends TNumber> Lgamma<T> lgamma(Operand<T> x) {
    * @param x
    * @return a new instance of Log
    */
-  public <T extends TType> Log<T> log(Operand<T> x) {
+  public <T extends Tensor> Log<T> log(Operand<T> x) {
     return Log.create(scope, x);
   }
 
@@ -1374,7 +1376,7 @@ public <T extends TType> Log<T> log(Operand<T> x) {
    * @param x
    * @return a new instance of Log1p
    */
-  public <T extends TType> Log1p<T> log1p(Operand<T> x) {
+  public <T extends Tensor> Log1p<T> log1p(Operand<T> x) {
     return Log1p.create(scope, x);
   }
 
@@ -1427,7 +1429,7 @@ public LogicalOr logicalOr(Operand<TBool> x, Operand<TBool> y) {
    * @param y
    * @return a new instance of Maximum
    */
-  public <T extends TNumber> Maximum<T> maximum(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> Maximum<T> maximum(Operand<T> x, Operand<T> y) {
     return Maximum.create(scope, x, y);
   }
 
@@ -1446,8 +1448,8 @@ public <T extends TNumber> Maximum<T> maximum(Operand<T> x, Operand<T> y) {
    * @param options carries optional attributes values
    * @return a new instance of Mean
    */
-  public <T extends TType, U extends TNumber> Mean<T> mean(Operand<T> input, Operand<U> axis,
-      Mean.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> Mean<T> mean(Operand<T> input,
+      Operand<U> axis, Mean.Options... options) {
     return Mean.create(scope, input, axis, options);
   }
 
@@ -1462,7 +1464,7 @@ public <T extends TType, U extends TNumber> Mean<T> mean(Operand<T> input, Opera
    * @param y
    * @return a new instance of Minimum
    */
-  public <T extends TNumber> Minimum<T> minimum(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> Minimum<T> minimum(Operand<T> x, Operand<T> y) {
     return Minimum.create(scope, x, y);
   }
 
@@ -1480,7 +1482,7 @@ public <T extends TNumber> Minimum<T> minimum(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Mod
    */
-  public <T extends TNumber> Mod<T> mod(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> Mod<T> mod(Operand<T> x, Operand<T> y) {
     return Mod.create(scope, x, y);
   }
 
@@ -1495,7 +1497,7 @@ public <T extends TNumber> Mod<T> mod(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Mul
    */
-  public <T extends TType> Mul<T> mul(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Mul<T> mul(Operand<T> x, Operand<T> y) {
     return Mul.create(scope, x, y);
   }
 
@@ -1510,7 +1512,7 @@ public <T extends TType> Mul<T> mul(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of MulNoNan
    */
-  public <T extends TType> MulNoNan<T> mulNoNan(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> MulNoNan<T> mulNoNan(Operand<T> x, Operand<T> y) {
     return MulNoNan.create(scope, x, y);
   }
 
@@ -1520,7 +1522,7 @@ public <T extends TType> MulNoNan<T> mulNoNan(Operand<T> x, Operand<T> y) {
    * @param x
    * @return a new instance of Ndtri
    */
-  public <T extends TNumber> Ndtri<T> ndtri(Operand<T> x) {
+  public <T extends Tensor & TNumber> Ndtri<T> ndtri(Operand<T> x) {
     return Ndtri.create(scope, x);
   }
 
@@ -1533,7 +1535,7 @@ public <T extends TNumber> Ndtri<T> ndtri(Operand<T> x) {
    * @param x
    * @return a new instance of Neg
    */
-  public <T extends TType> Neg<T> neg(Operand<T> x) {
+  public <T extends Tensor> Neg<T> neg(Operand<T> x) {
     return Neg.create(scope, x);
   }
 
@@ -1552,7 +1554,7 @@ public <T extends TType> Neg<T> neg(Operand<T> x) {
    * @param x2
    * @return a new instance of NextAfter
    */
-  public <T extends TNumber> NextAfter<T> nextAfter(Operand<T> x1, Operand<T> x2) {
+  public <T extends Tensor & TNumber> NextAfter<T> nextAfter(Operand<T> x1, Operand<T> x2) {
     return NextAfter.create(scope, x1, x2);
   }
 
@@ -1567,7 +1569,7 @@ public <T extends TNumber> NextAfter<T> nextAfter(Operand<T> x1, Operand<T> x2)
    * @param options carries optional attributes values
    * @return a new instance of NotEqual
    */
-  public <T extends TType> NotEqual notEqual(Operand<T> x, Operand<T> y,
+  public <T extends Tensor> NotEqual notEqual(Operand<T> x, Operand<T> y,
       NotEqual.Options... options) {
     return NotEqual.create(scope, x, y, options);
   }
@@ -1587,7 +1589,7 @@ public <T extends TType> NotEqual notEqual(Operand<T> x, Operand<T> y,
    * @param x
    * @return a new instance of Polygamma
    */
-  public <T extends TNumber> Polygamma<T> polygamma(Operand<T> a, Operand<T> x) {
+  public <T extends Tensor & TNumber> Polygamma<T> polygamma(Operand<T> a, Operand<T> x) {
     return Polygamma.create(scope, a, x);
   }
 
@@ -1604,7 +1606,7 @@ public <T extends TNumber> Polygamma<T> polygamma(Operand<T> a, Operand<T> x) {
    * @param x
    * @return a new instance of PopulationCount
    */
-  public <T extends TNumber> PopulationCount populationCount(Operand<T> x) {
+  public <T extends Tensor & TNumber> PopulationCount populationCount(Operand<T> x) {
     return PopulationCount.create(scope, x);
   }
 
@@ -1624,7 +1626,7 @@ public <T extends TNumber> PopulationCount populationCount(Operand<T> x) {
    * @param y
    * @return a new instance of Pow
    */
-  public <T extends TType> Pow<T> pow(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Pow<T> pow(Operand<T> x, Operand<T> y) {
     return Pow.create(scope, x, y);
   }
 
@@ -1641,7 +1643,7 @@ public <T extends TType> Pow<T> pow(Operand<T> x, Operand<T> y) {
    * @param Toutput
    * @return a new instance of QuantizedAdd
    */
-  public <V extends TType, T extends TType, U extends TType> QuantizedAdd<V> quantizedAdd(
+  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedAdd<V> quantizedAdd(
       Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX,
       Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     return QuantizedAdd.create(scope, x, y, minX, maxX, minY, maxY, Toutput);
@@ -1660,7 +1662,7 @@ public <V extends TType, T extends TType, U extends TType> QuantizedAdd<V> quant
    * @param Toutput
    * @return a new instance of QuantizedMul
    */
-  public <V extends TType, T extends TType, U extends TType> QuantizedMul<V> quantizedMul(
+  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedMul<V> quantizedMul(
       Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX,
       Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     return QuantizedMul.create(scope, x, y, minX, maxX, minY, maxY, Toutput);
@@ -1684,7 +1686,7 @@ public <V extends TType, T extends TType, U extends TType> QuantizedMul<V> quant
    * @param input
    * @return a new instance of Real
    */
-  public <T extends TType> Real<TFloat32> real(Operand<T> input) {
+  public <T extends Tensor> Real<TFloat32> real(Operand<T> input) {
     return Real.create(scope, input);
   }
 
@@ -1707,7 +1709,8 @@ public <T extends TType> Real<TFloat32> real(Operand<T> input) {
    * @param Tout
    * @return a new instance of Real
    */
-  public <U extends TNumber, T extends TType> Real<U> real(Operand<T> input, DataType<U> Tout) {
+  public <U extends Tensor & TNumber, T extends Tensor> Real<U> real(Operand<T> input,
+      DataType<U> Tout) {
     return Real.create(scope, input, Tout);
   }
 
@@ -1724,7 +1727,7 @@ public <U extends TNumber, T extends TType> Real<U> real(Operand<T> input, DataT
    * @param y
    * @return a new instance of RealDiv
    */
-  public <T extends TType> RealDiv<T> realDiv(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> RealDiv<T> realDiv(Operand<T> x, Operand<T> y) {
     return RealDiv.create(scope, x, y);
   }
 
@@ -1737,7 +1740,7 @@ public <T extends TType> RealDiv<T> realDiv(Operand<T> x, Operand<T> y) {
    * @param x
    * @return a new instance of Reciprocal
    */
-  public <T extends TType> Reciprocal<T> reciprocal(Operand<T> x) {
+  public <T extends Tensor> Reciprocal<T> reciprocal(Operand<T> x) {
     return Reciprocal.create(scope, x);
   }
 
@@ -1757,7 +1760,7 @@ public <T extends TType> Reciprocal<T> reciprocal(Operand<T> x) {
    * @param x
    * @return a new instance of Rint
    */
-  public <T extends TNumber> Rint<T> rint(Operand<T> x) {
+  public <T extends Tensor & TNumber> Rint<T> rint(Operand<T> x) {
     return Rint.create(scope, x);
   }
 
@@ -1771,7 +1774,7 @@ public <T extends TNumber> Rint<T> rint(Operand<T> x) {
    * @param x
    * @return a new instance of Round
    */
-  public <T extends TType> Round<T> round(Operand<T> x) {
+  public <T extends Tensor> Round<T> round(Operand<T> x) {
     return Round.create(scope, x);
   }
 
@@ -1784,7 +1787,7 @@ public <T extends TType> Round<T> round(Operand<T> x) {
    * @param x
    * @return a new instance of Rsqrt
    */
-  public <T extends TType> Rsqrt<T> rsqrt(Operand<T> x) {
+  public <T extends Tensor> Rsqrt<T> rsqrt(Operand<T> x) {
     return Rsqrt.create(scope, x);
   }
 
@@ -1819,8 +1822,8 @@ public <T extends TType> Rsqrt<T> rsqrt(Operand<T> x) {
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentMax
    */
-  public <T extends TNumber, U extends TNumber> SegmentMax<T> segmentMax(Operand<T> data,
-      Operand<U> segmentIds) {
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMax<T> segmentMax(
+      Operand<T> data, Operand<U> segmentIds) {
     return SegmentMax.create(scope, data, segmentIds);
   }
 
@@ -1856,7 +1859,7 @@ public <T extends TNumber, U extends TNumber> SegmentMax<T> segmentMax(Operand<T
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentMean
    */
-  public <T extends TType, U extends TNumber> SegmentMean<T> segmentMean(Operand<T> data,
+  public <T extends Tensor, U extends Tensor & TNumber> SegmentMean<T> segmentMean(Operand<T> data,
       Operand<U> segmentIds) {
     return SegmentMean.create(scope, data, segmentIds);
   }
@@ -1892,8 +1895,8 @@ public <T extends TType, U extends TNumber> SegmentMean<T> segmentMean(Operand<T
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentMin
    */
-  public <T extends TNumber, U extends TNumber> SegmentMin<T> segmentMin(Operand<T> data,
-      Operand<U> segmentIds) {
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMin<T> segmentMin(
+      Operand<T> data, Operand<U> segmentIds) {
     return SegmentMin.create(scope, data, segmentIds);
   }
 
@@ -1928,7 +1931,7 @@ public <T extends TNumber, U extends TNumber> SegmentMin<T> segmentMin(Operand<T
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentProd
    */
-  public <T extends TType, U extends TNumber> SegmentProd<T> segmentProd(Operand<T> data,
+  public <T extends Tensor, U extends Tensor & TNumber> SegmentProd<T> segmentProd(Operand<T> data,
       Operand<U> segmentIds) {
     return SegmentProd.create(scope, data, segmentIds);
   }
@@ -1964,7 +1967,7 @@ public <T extends TType, U extends TNumber> SegmentProd<T> segmentProd(Operand<T
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentSum
    */
-  public <T extends TType, U extends TNumber> SegmentSum<T> segmentSum(Operand<T> data,
+  public <T extends Tensor, U extends Tensor & TNumber> SegmentSum<T> segmentSum(Operand<T> data,
       Operand<U> segmentIds) {
     return SegmentSum.create(scope, data, segmentIds);
   }
@@ -1978,7 +1981,7 @@ public <T extends TType, U extends TNumber> SegmentSum<T> segmentSum(Operand<T>
    * @param x
    * @return a new instance of Sigmoid
    */
-  public <T extends TType> Sigmoid<T> sigmoid(Operand<T> x) {
+  public <T extends Tensor> Sigmoid<T> sigmoid(Operand<T> x) {
     return Sigmoid.create(scope, x);
   }
 
@@ -1997,7 +2000,7 @@ public <T extends TType> Sigmoid<T> sigmoid(Operand<T> x) {
    * @param x
    * @return a new instance of Sign
    */
-  public <T extends TType> Sign<T> sign(Operand<T> x) {
+  public <T extends Tensor> Sign<T> sign(Operand<T> x) {
     return Sign.create(scope, x);
   }
 
@@ -2017,7 +2020,7 @@ public <T extends TType> Sign<T> sign(Operand<T> x) {
    * @param x
    * @return a new instance of Sin
    */
-  public <T extends TType> Sin<T> sin(Operand<T> x) {
+  public <T extends Tensor> Sin<T> sin(Operand<T> x) {
     return Sin.create(scope, x);
   }
 
@@ -2037,7 +2040,7 @@ public <T extends TType> Sin<T> sin(Operand<T> x) {
    * @param x
    * @return a new instance of Sinh
    */
-  public <T extends TType> Sinh<T> sinh(Operand<T> x) {
+  public <T extends Tensor> Sinh<T> sinh(Operand<T> x) {
     return Sinh.create(scope, x);
   }
 
@@ -2048,7 +2051,7 @@ public <T extends TType> Sinh<T> sinh(Operand<T> x) {
    * @param features
    * @return a new instance of Softplus
    */
-  public <T extends TNumber> Softplus<T> softplus(Operand<T> features) {
+  public <T extends Tensor & TNumber> Softplus<T> softplus(Operand<T> features) {
     return Softplus.create(scope, features);
   }
 
@@ -2061,7 +2064,7 @@ public <T extends TNumber> Softplus<T> softplus(Operand<T> features) {
    * @param x
    * @return a new instance of Sqrt
    */
-  public <T extends TType> Sqrt<T> sqrt(Operand<T> x) {
+  public <T extends Tensor> Sqrt<T> sqrt(Operand<T> x) {
     return Sqrt.create(scope, x);
   }
 
@@ -2074,7 +2077,7 @@ public <T extends TType> Sqrt<T> sqrt(Operand<T> x) {
    * @param x
    * @return a new instance of Square
    */
-  public <T extends TType> Square<T> square(Operand<T> x) {
+  public <T extends Tensor> Square<T> square(Operand<T> x) {
     return Square.create(scope, x);
   }
 
@@ -2089,7 +2092,7 @@ public <T extends TType> Square<T> square(Operand<T> x) {
    * @param y
    * @return a new instance of SquaredDifference
    */
-  public <T extends TType> SquaredDifference<T> squaredDifference(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> SquaredDifference<T> squaredDifference(Operand<T> x, Operand<T> y) {
     return SquaredDifference.create(scope, x, y);
   }
 
@@ -2104,7 +2107,7 @@ public <T extends TType> SquaredDifference<T> squaredDifference(Operand<T> x, Op
    * @param y
    * @return a new instance of Sub
    */
-  public <T extends TType> Sub<T> sub(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Sub<T> sub(Operand<T> x, Operand<T> y) {
     return Sub.create(scope, x, y);
   }
 
@@ -2125,7 +2128,7 @@ public <T extends TType> Sub<T> sub(Operand<T> x, Operand<T> y) {
    * @param x
    * @return a new instance of Tan
    */
-  public <T extends TType> Tan<T> tan(Operand<T> x) {
+  public <T extends Tensor> Tan<T> tan(Operand<T> x) {
     return Tan.create(scope, x);
   }
 
@@ -2145,7 +2148,7 @@ public <T extends TType> Tan<T> tan(Operand<T> x) {
    * @param x
    * @return a new instance of Tanh
    */
-  public <T extends TType> Tanh<T> tanh(Operand<T> x) {
+  public <T extends Tensor> Tanh<T> tanh(Operand<T> x) {
     return Tanh.create(scope, x);
   }
 
@@ -2165,7 +2168,7 @@ public <T extends TType> Tanh<T> tanh(Operand<T> x) {
    * @param y
    * @return a new instance of TruncateDiv
    */
-  public <T extends TType> TruncateDiv<T> truncateDiv(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> TruncateDiv<T> truncateDiv(Operand<T> x, Operand<T> y) {
     return TruncateDiv.create(scope, x, y);
   }
 
@@ -2183,7 +2186,7 @@ public <T extends TType> TruncateDiv<T> truncateDiv(Operand<T> x, Operand<T> y)
    * @param y
    * @return a new instance of TruncateMod
    */
-  public <T extends TNumber> TruncateMod<T> truncateMod(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor & TNumber> TruncateMod<T> truncateMod(Operand<T> x, Operand<T> y) {
     return TruncateMod.create(scope, x, y);
   }
 
@@ -2226,7 +2229,7 @@ public <T extends TNumber> TruncateMod<T> truncateMod(Operand<T> x, Operand<T> y
    * @param numSegments
    * @return a new instance of UnsortedSegmentMax
    */
-  public <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMax<T> unsortedSegmentMax(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMax<T> unsortedSegmentMax(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentMax.create(scope, data, segmentIds, numSegments);
   }
@@ -2265,7 +2268,7 @@ public <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegment
    * @param numSegments
    * @return a new instance of UnsortedSegmentMin
    */
-  public <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMin<T> unsortedSegmentMin(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMin<T> unsortedSegmentMin(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentMin.create(scope, data, segmentIds, numSegments);
   }
@@ -2303,7 +2306,7 @@ public <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegment
    * @param numSegments
    * @return a new instance of UnsortedSegmentProd
    */
-  public <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentProd<T> unsortedSegmentProd(
+  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentProd<T> unsortedSegmentProd(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentProd.create(scope, data, segmentIds, numSegments);
   }
@@ -2343,7 +2346,7 @@ public <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentPr
    * @param numSegments
    * @return a new instance of UnsortedSegmentSum
    */
-  public <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentSum<T> unsortedSegmentSum(
+  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentSum<T> unsortedSegmentSum(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentSum.create(scope, data, segmentIds, numSegments);
   }
@@ -2356,7 +2359,7 @@ public <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentSu
    * @param y
    * @return a new instance of Xdivy
    */
-  public <T extends TType> Xdivy<T> xdivy(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Xdivy<T> xdivy(Operand<T> x, Operand<T> y) {
     return Xdivy.create(scope, x, y);
   }
 
@@ -2368,7 +2371,7 @@ public <T extends TType> Xdivy<T> xdivy(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Xlog1py
    */
-  public <T extends TType> Xlog1py<T> xlog1py(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Xlog1py<T> xlog1py(Operand<T> x, Operand<T> y) {
     return Xlog1py.create(scope, x, y);
   }
 
@@ -2380,7 +2383,7 @@ public <T extends TType> Xlog1py<T> xlog1py(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Xlogy
    */
-  public <T extends TType> Xlogy<T> xlogy(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> Xlogy<T> xlogy(Operand<T> x, Operand<T> y) {
     return Xlogy.create(scope, x, y);
   }
 
@@ -2396,7 +2399,7 @@ public <T extends TType> Xlogy<T> xlogy(Operand<T> x, Operand<T> y) {
    * @param q
    * @return a new instance of Zeta
    */
-  public <T extends TNumber> Zeta<T> zeta(Operand<T> x, Operand<T> q) {
+  public <T extends Tensor & TNumber> Zeta<T> zeta(Operand<T> x, Operand<T> q) {
     return Zeta.create(scope, x, q);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java
index 0c76b961cf4..ebb56767bce 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java
@@ -20,6 +20,7 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.nn.AvgPool;
 import org.tensorflow.op.nn.AvgPool3d;
 import org.tensorflow.op.nn.AvgPool3dGrad;
@@ -94,7 +95,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code nn} operations as {@link Op Op}s
@@ -122,7 +122,7 @@ public final class NnOps {
    * @param options carries optional attributes values
    * @return a new instance of AvgPool
    */
-  public <T extends TNumber> AvgPool<T> avgPool(Operand<T> value, List<Long> ksize,
+  public <T extends Tensor & TNumber> AvgPool<T> avgPool(Operand<T> value, List<Long> ksize,
       List<Long> strides, String padding, AvgPool.Options... options) {
     return AvgPool.create(scope, value, ksize, strides, padding, options);
   }
@@ -140,7 +140,7 @@ public <T extends TNumber> AvgPool<T> avgPool(Operand<T> value, List<Long> ksize
    * @param options carries optional attributes values
    * @return a new instance of AvgPool3d
    */
-  public <T extends TNumber> AvgPool3d<T> avgPool3d(Operand<T> input, List<Long> ksize,
+  public <T extends Tensor & TNumber> AvgPool3d<T> avgPool3d(Operand<T> input, List<Long> ksize,
       List<Long> strides, String padding, AvgPool3d.Options... options) {
     return AvgPool3d.create(scope, input, ksize, strides, padding, options);
   }
@@ -159,7 +159,7 @@ public <T extends TNumber> AvgPool3d<T> avgPool3d(Operand<T> input, List<Long> k
    * @param options carries optional attributes values
    * @return a new instance of AvgPool3dGrad
    */
-  public <T extends TNumber> AvgPool3dGrad<T> avgPool3dGrad(Operand<TInt32> origInputShape,
+  public <T extends Tensor & TNumber> AvgPool3dGrad<T> avgPool3dGrad(Operand<TInt32> origInputShape,
       Operand<T> grad, List<Long> ksize, List<Long> strides, String padding,
       AvgPool3dGrad.Options... options) {
     return AvgPool3dGrad.create(scope, origInputShape, grad, ksize, strides, padding, options);
@@ -188,7 +188,7 @@ public <T extends TNumber> AvgPool3dGrad<T> avgPool3dGrad(Operand<TInt32> origIn
    *  needs to be multiplied with gamma.
    * @return a new instance of BatchNormWithGlobalNormalization
    */
-  public <T extends TType> BatchNormWithGlobalNormalization<T> batchNormWithGlobalNormalization(
+  public <T extends Tensor> BatchNormWithGlobalNormalization<T> batchNormWithGlobalNormalization(
       Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> beta, Operand<T> gamma,
       Float varianceEpsilon, Boolean scaleAfterNormalization) {
     return BatchNormWithGlobalNormalization.create(scope, t, m, v, beta, gamma, varianceEpsilon, scaleAfterNormalization);
@@ -216,7 +216,7 @@ public <T extends TType> BatchNormWithGlobalNormalization<T> batchNormWithGlobal
    *  needs to be multiplied with gamma.
    * @return a new instance of BatchNormWithGlobalNormalizationGrad
    */
-  public <T extends TType> BatchNormWithGlobalNormalizationGrad<T> batchNormWithGlobalNormalizationGrad(
+  public <T extends Tensor> BatchNormWithGlobalNormalizationGrad<T> batchNormWithGlobalNormalizationGrad(
       Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> gamma, Operand<T> backprop,
       Float varianceEpsilon, Boolean scaleAfterNormalization) {
     return BatchNormWithGlobalNormalizationGrad.create(scope, t, m, v, gamma, backprop, varianceEpsilon, scaleAfterNormalization);
@@ -234,7 +234,7 @@ public <T extends TType> BatchNormWithGlobalNormalizationGrad<T> batchNormWithGl
    * @param options carries optional attributes values
    * @return a new instance of BiasAdd
    */
-  public <T extends TType> BiasAdd<T> biasAdd(Operand<T> value, Operand<T> bias,
+  public <T extends Tensor> BiasAdd<T> biasAdd(Operand<T> value, Operand<T> bias,
       BiasAdd.Options... options) {
     return BiasAdd.create(scope, value, bias, options);
   }
@@ -251,7 +251,7 @@ public <T extends TType> BiasAdd<T> biasAdd(Operand<T> value, Operand<T> bias,
    * @param options carries optional attributes values
    * @return a new instance of BiasAddGrad
    */
-  public <T extends TType> BiasAddGrad<T> biasAddGrad(Operand<T> outBackprop,
+  public <T extends Tensor> BiasAddGrad<T> biasAddGrad(Operand<T> outBackprop,
       BiasAddGrad.Options... options) {
     return BiasAddGrad.create(scope, outBackprop, options);
   }
@@ -312,7 +312,7 @@ public ComputeAccidentalHits computeAccidentalHits(Operand<TInt64> trueClasses,
    * @param options carries optional attributes values
    * @return a new instance of Conv2d
    */
-  public <T extends TNumber> Conv2d<T> conv2d(Operand<T> input, Operand<T> filter,
+  public <T extends Tensor & TNumber> Conv2d<T> conv2d(Operand<T> input, Operand<T> filter,
       List<Long> strides, String padding, Conv2d.Options... options) {
     return Conv2d.create(scope, input, filter, strides, padding, options);
   }
@@ -334,7 +334,7 @@ public <T extends TNumber> Conv2d<T> conv2d(Operand<T> input, Operand<T> filter,
    * @param options carries optional attributes values
    * @return a new instance of Conv2dBackpropFilter
    */
-  public <T extends TNumber> Conv2dBackpropFilter<T> conv2dBackpropFilter(Operand<T> input,
+  public <T extends Tensor & TNumber> Conv2dBackpropFilter<T> conv2dBackpropFilter(Operand<T> input,
       Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding,
       Conv2dBackpropFilter.Options... options) {
     return Conv2dBackpropFilter.create(scope, input, filterSizes, outBackprop, strides, padding, options);
@@ -357,9 +357,9 @@ public <T extends TNumber> Conv2dBackpropFilter<T> conv2dBackpropFilter(Operand<
    * @param options carries optional attributes values
    * @return a new instance of Conv2dBackpropInput
    */
-  public <T extends TNumber> Conv2dBackpropInput<T> conv2dBackpropInput(Operand<TInt32> inputSizes,
-      Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding,
-      Conv2dBackpropInput.Options... options) {
+  public <T extends Tensor & TNumber> Conv2dBackpropInput<T> conv2dBackpropInput(
+      Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
+      String padding, Conv2dBackpropInput.Options... options) {
     return Conv2dBackpropInput.create(scope, inputSizes, filter, outBackprop, strides, padding, options);
   }
 
@@ -382,7 +382,7 @@ public <T extends TNumber> Conv2dBackpropInput<T> conv2dBackpropInput(Operand<TI
    * @param options carries optional attributes values
    * @return a new instance of Conv3d
    */
-  public <T extends TNumber> Conv3d<T> conv3d(Operand<T> input, Operand<T> filter,
+  public <T extends Tensor & TNumber> Conv3d<T> conv3d(Operand<T> input, Operand<T> filter,
       List<Long> strides, String padding, Conv3d.Options... options) {
     return Conv3d.create(scope, input, filter, strides, padding, options);
   }
@@ -404,7 +404,7 @@ public <T extends TNumber> Conv3d<T> conv3d(Operand<T> input, Operand<T> filter,
    * @param options carries optional attributes values
    * @return a new instance of Conv3dBackpropFilter
    */
-  public <T extends TNumber> Conv3dBackpropFilter<T> conv3dBackpropFilter(Operand<T> input,
+  public <T extends Tensor & TNumber> Conv3dBackpropFilter<T> conv3dBackpropFilter(Operand<T> input,
       Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding,
       Conv3dBackpropFilter.Options... options) {
     return Conv3dBackpropFilter.create(scope, input, filterSizes, outBackprop, strides, padding, options);
@@ -427,7 +427,7 @@ public <T extends TNumber> Conv3dBackpropFilter<T> conv3dBackpropFilter(Operand<
    * @param options carries optional attributes values
    * @return a new instance of Conv3dBackpropInput
    */
-  public <U extends TNumber, T extends TNumber> Conv3dBackpropInput<U> conv3dBackpropInput(
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> Conv3dBackpropInput<U> conv3dBackpropInput(
       Operand<T> inputSizes, Operand<U> filter, Operand<U> outBackprop, List<Long> strides,
       String padding, Conv3dBackpropInput.Options... options) {
     return Conv3dBackpropInput.create(scope, inputSizes, filter, outBackprop, strides, padding, options);
@@ -450,8 +450,8 @@ public <U extends TNumber, T extends TNumber> Conv3dBackpropInput<U> conv3dBackp
    * @param options carries optional attributes values
    * @return a new instance of CtcBeamSearchDecoder
    */
-  public <T extends TNumber> CtcBeamSearchDecoder<T> ctcBeamSearchDecoder(Operand<T> inputs,
-      Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths,
+  public <T extends Tensor & TNumber> CtcBeamSearchDecoder<T> ctcBeamSearchDecoder(
+      Operand<T> inputs, Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths,
       CtcBeamSearchDecoder.Options... options) {
     return CtcBeamSearchDecoder.create(scope, inputs, sequenceLength, beamWidth, topPaths, options);
   }
@@ -475,7 +475,7 @@ public <T extends TNumber> CtcBeamSearchDecoder<T> ctcBeamSearchDecoder(Operand<
    * @param options carries optional attributes values
    * @return a new instance of CtcGreedyDecoder
    */
-  public <T extends TNumber> CtcGreedyDecoder<T> ctcGreedyDecoder(Operand<T> inputs,
+  public <T extends Tensor & TNumber> CtcGreedyDecoder<T> ctcGreedyDecoder(Operand<T> inputs,
       Operand<TInt32> sequenceLength, CtcGreedyDecoder.Options... options) {
     return CtcGreedyDecoder.create(scope, inputs, sequenceLength, options);
   }
@@ -496,8 +496,9 @@ public <T extends TNumber> CtcGreedyDecoder<T> ctcGreedyDecoder(Operand<T> input
    * @param options carries optional attributes values
    * @return a new instance of CtcLoss
    */
-  public <T extends TNumber> CtcLoss<T> ctcLoss(Operand<T> inputs, Operand<TInt64> labelsIndices,
-      Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength, CtcLoss.Options... options) {
+  public <T extends Tensor & TNumber> CtcLoss<T> ctcLoss(Operand<T> inputs,
+      Operand<TInt64> labelsIndices, Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength,
+      CtcLoss.Options... options) {
     return CtcLoss.create(scope, inputs, labelsIndices, labelsValues, sequenceLength, options);
   }
 
@@ -544,7 +545,7 @@ public <T extends TNumber> CtcLoss<T> ctcLoss(Operand<T> inputs, Operand<TInt64>
    * @param options carries optional attributes values
    * @return a new instance of CudnnRNNCanonicalToParams
    */
-  public <T extends TNumber> CudnnRNNCanonicalToParams<T> cudnnRNNCanonicalToParams(
+  public <T extends Tensor & TNumber> CudnnRNNCanonicalToParams<T> cudnnRNNCanonicalToParams(
       Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize,
       Iterable<Operand<T>> weights, Iterable<Operand<T>> biases,
       CudnnRNNCanonicalToParams.Options... options) {
@@ -595,7 +596,7 @@ public <T extends TNumber> CudnnRNNCanonicalToParams<T> cudnnRNNCanonicalToParam
    * @param options carries optional attributes values
    * @return a new instance of CudnnRNNParamsToCanonical
    */
-  public <T extends TNumber> CudnnRNNParamsToCanonical<T> cudnnRNNParamsToCanonical(
+  public <T extends Tensor & TNumber> CudnnRNNParamsToCanonical<T> cudnnRNNParamsToCanonical(
       Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize,
       Operand<T> params, Long numParamsWeights, Long numParamsBiases,
       CudnnRNNParamsToCanonical.Options... options) {
@@ -636,7 +637,7 @@ public <T extends TNumber> CudnnRNNParamsToCanonical<T> cudnnRNNParamsToCanonica
    * @param options carries optional attributes values
    * @return a new instance of CudnnRnnParamsSize
    */
-  public <U extends TNumber, T extends TNumber> CudnnRnnParamsSize<U> cudnnRnnParamsSize(
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> CudnnRnnParamsSize<U> cudnnRnnParamsSize(
       Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, DataType<T> T,
       DataType<U> S, CudnnRnnParamsSize.Options... options) {
     return CudnnRnnParamsSize.create(scope, numLayers, numUnits, inputSize, T, S, options);
@@ -653,7 +654,7 @@ public <U extends TNumber, T extends TNumber> CudnnRnnParamsSize<U> cudnnRnnPara
    * @param options carries optional attributes values
    * @return a new instance of DataFormatDimMap
    */
-  public <T extends TNumber> DataFormatDimMap<T> dataFormatDimMap(Operand<T> x,
+  public <T extends Tensor & TNumber> DataFormatDimMap<T> dataFormatDimMap(Operand<T> x,
       DataFormatDimMap.Options... options) {
     return DataFormatDimMap.create(scope, x, options);
   }
@@ -668,7 +669,7 @@ public <T extends TNumber> DataFormatDimMap<T> dataFormatDimMap(Operand<T> x,
    * @param options carries optional attributes values
    * @return a new instance of DataFormatVecPermute
    */
-  public <T extends TNumber> DataFormatVecPermute<T> dataFormatVecPermute(Operand<T> x,
+  public <T extends Tensor & TNumber> DataFormatVecPermute<T> dataFormatVecPermute(Operand<T> x,
       DataFormatVecPermute.Options... options) {
     return DataFormatVecPermute.create(scope, x, options);
   }
@@ -761,7 +762,7 @@ public <T extends TNumber> DataFormatVecPermute<T> dataFormatVecPermute(Operand<
    * @param options carries optional attributes values
    * @return a new instance of DepthToSpace
    */
-  public <T extends TType> DepthToSpace<T> depthToSpace(Operand<T> input, Long blockSize,
+  public <T extends Tensor> DepthToSpace<T> depthToSpace(Operand<T> input, Long blockSize,
       DepthToSpace.Options... options) {
     return DepthToSpace.create(scope, input, blockSize, options);
   }
@@ -795,8 +796,8 @@ public <T extends TType> DepthToSpace<T> depthToSpace(Operand<T> input, Long blo
    * @param options carries optional attributes values
    * @return a new instance of DepthwiseConv2dNative
    */
-  public <T extends TNumber> DepthwiseConv2dNative<T> depthwiseConv2dNative(Operand<T> input,
-      Operand<T> filter, List<Long> strides, String padding,
+  public <T extends Tensor & TNumber> DepthwiseConv2dNative<T> depthwiseConv2dNative(
+      Operand<T> input, Operand<T> filter, List<Long> strides, String padding,
       DepthwiseConv2dNative.Options... options) {
     return DepthwiseConv2dNative.create(scope, input, filter, strides, padding, options);
   }
@@ -821,7 +822,7 @@ public <T extends TNumber> DepthwiseConv2dNative<T> depthwiseConv2dNative(Operan
    * @param options carries optional attributes values
    * @return a new instance of DepthwiseConv2dNativeBackpropFilter
    */
-  public <T extends TNumber> DepthwiseConv2dNativeBackpropFilter<T> depthwiseConv2dNativeBackpropFilter(
+  public <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropFilter<T> depthwiseConv2dNativeBackpropFilter(
       Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides,
       String padding, DepthwiseConv2dNativeBackpropFilter.Options... options) {
     return DepthwiseConv2dNativeBackpropFilter.create(scope, input, filterSizes, outBackprop, strides, padding, options);
@@ -846,7 +847,7 @@ public <T extends TNumber> DepthwiseConv2dNativeBackpropFilter<T> depthwiseConv2
    * @param options carries optional attributes values
    * @return a new instance of DepthwiseConv2dNativeBackpropInput
    */
-  public <T extends TNumber> DepthwiseConv2dNativeBackpropInput<T> depthwiseConv2dNativeBackpropInput(
+  public <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropInput<T> depthwiseConv2dNativeBackpropInput(
       Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
       String padding, DepthwiseConv2dNativeBackpropInput.Options... options) {
     return DepthwiseConv2dNativeBackpropInput.create(scope, inputSizes, filter, outBackprop, strides, padding, options);
@@ -889,7 +890,7 @@ public <T extends TNumber> DepthwiseConv2dNativeBackpropInput<T> depthwiseConv2d
    * @param padding The type of padding algorithm to use.
    * @return a new instance of Dilation2d
    */
-  public <T extends TNumber> Dilation2d<T> dilation2d(Operand<T> input, Operand<T> filter,
+  public <T extends Tensor & TNumber> Dilation2d<T> dilation2d(Operand<T> input, Operand<T> filter,
       List<Long> strides, List<Long> rates, String padding) {
     return Dilation2d.create(scope, input, filter, strides, rates, padding);
   }
@@ -908,9 +909,9 @@ public <T extends TNumber> Dilation2d<T> dilation2d(Operand<T> input, Operand<T>
    * @param padding The type of padding algorithm to use.
    * @return a new instance of Dilation2dBackpropFilter
    */
-  public <T extends TNumber> Dilation2dBackpropFilter<T> dilation2dBackpropFilter(Operand<T> input,
-      Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates,
-      String padding) {
+  public <T extends Tensor & TNumber> Dilation2dBackpropFilter<T> dilation2dBackpropFilter(
+      Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
+      List<Long> rates, String padding) {
     return Dilation2dBackpropFilter.create(scope, input, filter, outBackprop, strides, rates, padding);
   }
 
@@ -928,9 +929,9 @@ public <T extends TNumber> Dilation2dBackpropFilter<T> dilation2dBackpropFilter(
    * @param padding The type of padding algorithm to use.
    * @return a new instance of Dilation2dBackpropInput
    */
-  public <T extends TNumber> Dilation2dBackpropInput<T> dilation2dBackpropInput(Operand<T> input,
-      Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates,
-      String padding) {
+  public <T extends Tensor & TNumber> Dilation2dBackpropInput<T> dilation2dBackpropInput(
+      Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
+      List<Long> rates, String padding) {
     return Dilation2dBackpropInput.create(scope, input, filter, outBackprop, strides, rates, padding);
   }
 
@@ -944,7 +945,7 @@ public <T extends TNumber> Dilation2dBackpropInput<T> dilation2dBackpropInput(Op
    * @param features
    * @return a new instance of Elu
    */
-  public <T extends TNumber> Elu<T> elu(Operand<T> features) {
+  public <T extends Tensor & TNumber> Elu<T> elu(Operand<T> features) {
     return Elu.create(scope, features);
   }
 
@@ -1002,7 +1003,7 @@ public FixedUnigramCandidateSampler fixedUnigramCandidateSampler(Operand<TInt64>
    * @param options carries optional attributes values
    * @return a new instance of FractionalAvgPool
    */
-  public <T extends TNumber> FractionalAvgPool<T> fractionalAvgPool(Operand<T> value,
+  public <T extends Tensor & TNumber> FractionalAvgPool<T> fractionalAvgPool(Operand<T> value,
       List<Float> poolingRatio, FractionalAvgPool.Options... options) {
     return FractionalAvgPool.create(scope, value, poolingRatio, options);
   }
@@ -1050,7 +1051,7 @@ public <T extends TNumber> FractionalAvgPool<T> fractionalAvgPool(Operand<T> val
    * @param options carries optional attributes values
    * @return a new instance of FractionalMaxPool
    */
-  public <T extends TNumber> FractionalMaxPool<T> fractionalMaxPool(Operand<T> value,
+  public <T extends Tensor & TNumber> FractionalMaxPool<T> fractionalMaxPool(Operand<T> value,
       List<Float> poolingRatio, FractionalMaxPool.Options... options) {
     return FractionalMaxPool.create(scope, value, poolingRatio, options);
   }
@@ -1073,8 +1074,8 @@ public <T extends TNumber> FractionalMaxPool<T> fractionalMaxPool(Operand<T> val
    * @param options carries optional attributes values
    * @return a new instance of FusedBatchNorm
    */
-  public <T extends TNumber, U extends TNumber> FusedBatchNorm<T, U> fusedBatchNorm(Operand<T> x,
-      Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance,
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNorm<T, U> fusedBatchNorm(
+      Operand<T> x, Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance,
       FusedBatchNorm.Options... options) {
     return FusedBatchNorm.create(scope, x, scale, offset, mean, variance, options);
   }
@@ -1105,7 +1106,7 @@ public <T extends TNumber, U extends TNumber> FusedBatchNorm<T, U> fusedBatchNor
    * @param options carries optional attributes values
    * @return a new instance of FusedBatchNormGrad
    */
-  public <T extends TNumber, U extends TNumber> FusedBatchNormGrad<T, U> fusedBatchNormGrad(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNormGrad<T, U> fusedBatchNormGrad(
       Operand<T> yBackprop, Operand<T> x, Operand<TFloat32> scale, Operand<U> reserveSpace1,
       Operand<U> reserveSpace2, Operand<U> reserveSpace3, FusedBatchNormGrad.Options... options) {
     return FusedBatchNormGrad.create(scope, yBackprop, x, scale, reserveSpace1, reserveSpace2, reserveSpace3, options);
@@ -1138,7 +1139,7 @@ public <T extends TNumber, U extends TNumber> FusedBatchNormGrad<T, U> fusedBatc
    * @param padding The type of padding algorithm to use.
    * @return a new instance of FusedPadConv2d
    */
-  public <T extends TNumber> FusedPadConv2d<T> fusedPadConv2d(Operand<T> input,
+  public <T extends Tensor & TNumber> FusedPadConv2d<T> fusedPadConv2d(Operand<T> input,
       Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides,
       String padding) {
     return FusedPadConv2d.create(scope, input, paddings, filter, mode, strides, padding);
@@ -1173,9 +1174,9 @@ public <T extends TNumber> FusedPadConv2d<T> fusedPadConv2d(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of FusedResizeAndPadConv2d
    */
-  public <T extends TNumber> FusedResizeAndPadConv2d<T> fusedResizeAndPadConv2d(Operand<T> input,
-      Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter, String mode,
-      List<Long> strides, String padding, FusedResizeAndPadConv2d.Options... options) {
+  public <T extends Tensor & TNumber> FusedResizeAndPadConv2d<T> fusedResizeAndPadConv2d(
+      Operand<T> input, Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter,
+      String mode, List<Long> strides, String padding, FusedResizeAndPadConv2d.Options... options) {
     return FusedResizeAndPadConv2d.create(scope, input, size, paddings, filter, mode, strides, padding, options);
   }
 
@@ -1202,8 +1203,8 @@ public <T extends TNumber> FusedResizeAndPadConv2d<T> fusedResizeAndPadConv2d(Op
    * @param k Number of top elements to look at for computing precision.
    * @return a new instance of InTopK
    */
-  public <T extends TNumber> InTopK inTopK(Operand<TFloat32> predictions, Operand<T> targets,
-      Operand<T> k) {
+  public <T extends Tensor & TNumber> InTopK inTopK(Operand<TFloat32> predictions,
+      Operand<T> targets, Operand<T> k) {
     return InTopK.create(scope, predictions, targets, k);
   }
 
@@ -1218,7 +1219,7 @@ public <T extends TNumber> InTopK inTopK(Operand<TFloat32> predictions, Operand<
    * @param t Typically 2-D, but may have any dimensions.
    * @return a new instance of L2Loss
    */
-  public <T extends TNumber> L2Loss<T> l2Loss(Operand<T> t) {
+  public <T extends Tensor & TNumber> L2Loss<T> l2Loss(Operand<T> t) {
     return L2Loss.create(scope, t);
   }
 
@@ -1272,7 +1273,7 @@ public LearnedUnigramCandidateSampler learnedUnigramCandidateSampler(Operand<TIn
    * @param options carries optional attributes values
    * @return a new instance of LocalResponseNormalization
    */
-  public <T extends TNumber> LocalResponseNormalization<T> localResponseNormalization(
+  public <T extends Tensor & TNumber> LocalResponseNormalization<T> localResponseNormalization(
       Operand<T> input, LocalResponseNormalization.Options... options) {
     return LocalResponseNormalization.create(scope, input, options);
   }
@@ -1288,7 +1289,7 @@ public <T extends TNumber> LocalResponseNormalization<T> localResponseNormalizat
    * @param logits 2-D with shape `[batch_size, num_classes]`.
    * @return a new instance of LogSoftmax
    */
-  public <T extends TNumber> LogSoftmax<T> logSoftmax(Operand<T> logits) {
+  public <T extends Tensor & TNumber> LogSoftmax<T> logSoftmax(Operand<T> logits) {
     return LogSoftmax.create(scope, logits);
   }
 
@@ -1304,7 +1305,7 @@ public <T extends TNumber> LogSoftmax<T> logSoftmax(Operand<T> logits) {
    * @param options carries optional attributes values
    * @return a new instance of MaxPool
    */
-  public <T extends TType> MaxPool<T> maxPool(Operand<T> input, Operand<TInt32> ksize,
+  public <T extends Tensor> MaxPool<T> maxPool(Operand<T> input, Operand<TInt32> ksize,
       Operand<TInt32> strides, String padding, MaxPool.Options... options) {
     return MaxPool.create(scope, input, ksize, strides, padding, options);
   }
@@ -1322,7 +1323,7 @@ public <T extends TType> MaxPool<T> maxPool(Operand<T> input, Operand<TInt32> ks
    * @param options carries optional attributes values
    * @return a new instance of MaxPool3d
    */
-  public <T extends TNumber> MaxPool3d<T> maxPool3d(Operand<T> input, List<Long> ksize,
+  public <T extends Tensor & TNumber> MaxPool3d<T> maxPool3d(Operand<T> input, List<Long> ksize,
       List<Long> strides, String padding, MaxPool3d.Options... options) {
     return MaxPool3d.create(scope, input, ksize, strides, padding, options);
   }
@@ -1342,9 +1343,9 @@ public <T extends TNumber> MaxPool3d<T> maxPool3d(Operand<T> input, List<Long> k
    * @param options carries optional attributes values
    * @return a new instance of MaxPool3dGrad
    */
-  public <U extends TNumber, T extends TNumber> MaxPool3dGrad<U> maxPool3dGrad(Operand<T> origInput,
-      Operand<T> origOutput, Operand<U> grad, List<Long> ksize, List<Long> strides, String padding,
-      MaxPool3dGrad.Options... options) {
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> MaxPool3dGrad<U> maxPool3dGrad(
+      Operand<T> origInput, Operand<T> origOutput, Operand<U> grad, List<Long> ksize,
+      List<Long> strides, String padding, MaxPool3dGrad.Options... options) {
     return MaxPool3dGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
   }
 
@@ -1363,7 +1364,7 @@ public <U extends TNumber, T extends TNumber> MaxPool3dGrad<U> maxPool3dGrad(Ope
    * @param options carries optional attributes values
    * @return a new instance of MaxPool3dGradGrad
    */
-  public <T extends TNumber> MaxPool3dGradGrad<T> maxPool3dGradGrad(Operand<T> origInput,
+  public <T extends Tensor & TNumber> MaxPool3dGradGrad<T> maxPool3dGradGrad(Operand<T> origInput,
       Operand<T> origOutput, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding,
       MaxPool3dGradGrad.Options... options) {
     return MaxPool3dGradGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
@@ -1383,9 +1384,9 @@ public <T extends TNumber> MaxPool3dGradGrad<T> maxPool3dGradGrad(Operand<T> ori
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolGrad
    */
-  public <T extends TNumber> MaxPoolGrad<T> maxPoolGrad(Operand<T> origInput, Operand<T> origOutput,
-      Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding,
-      MaxPoolGrad.Options... options) {
+  public <T extends Tensor & TNumber> MaxPoolGrad<T> maxPoolGrad(Operand<T> origInput,
+      Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides,
+      String padding, MaxPoolGrad.Options... options) {
     return MaxPoolGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
   }
 
@@ -1403,7 +1404,7 @@ public <T extends TNumber> MaxPoolGrad<T> maxPoolGrad(Operand<T> origInput, Oper
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolGradGrad
    */
-  public <T extends TNumber> MaxPoolGradGrad<T> maxPoolGradGrad(Operand<T> origInput,
+  public <T extends Tensor & TNumber> MaxPoolGradGrad<T> maxPoolGradGrad(Operand<T> origInput,
       Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides,
       String padding, MaxPoolGradGrad.Options... options) {
     return MaxPoolGradGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
@@ -1424,7 +1425,7 @@ public <T extends TNumber> MaxPoolGradGrad<T> maxPoolGradGrad(Operand<T> origInp
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolGradGradWithArgmax
    */
-  public <T extends TNumber, U extends TNumber> MaxPoolGradGradWithArgmax<T> maxPoolGradGradWithArgmax(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolGradGradWithArgmax<T> maxPoolGradGradWithArgmax(
       Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides,
       String padding, MaxPoolGradGradWithArgmax.Options... options) {
     return MaxPoolGradGradWithArgmax.create(scope, input, grad, argmax, ksize, strides, padding, options);
@@ -1453,8 +1454,9 @@ public <T extends TNumber, U extends TNumber> MaxPoolGradGradWithArgmax<T> maxPo
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolWithArgmax
    */
-  public <T extends TNumber> MaxPoolWithArgmax<T, TInt64> maxPoolWithArgmax(Operand<T> input,
-      List<Long> ksize, List<Long> strides, String padding, MaxPoolWithArgmax.Options... options) {
+  public <T extends Tensor & TNumber> MaxPoolWithArgmax<T, TInt64> maxPoolWithArgmax(
+      Operand<T> input, List<Long> ksize, List<Long> strides, String padding,
+      MaxPoolWithArgmax.Options... options) {
     return MaxPoolWithArgmax.create(scope, input, ksize, strides, padding, options);
   }
 
@@ -1482,7 +1484,7 @@ public <T extends TNumber> MaxPoolWithArgmax<T, TInt64> maxPoolWithArgmax(Operan
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolWithArgmax
    */
-  public <T extends TNumber, U extends TNumber> MaxPoolWithArgmax<T, U> maxPoolWithArgmax(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolWithArgmax<T, U> maxPoolWithArgmax(
       Operand<T> input, List<Long> ksize, List<Long> strides, DataType<U> Targmax, String padding,
       MaxPoolWithArgmax.Options... options) {
     return MaxPoolWithArgmax.create(scope, input, ksize, strides, Targmax, padding, options);
@@ -1506,7 +1508,7 @@ public <T extends TNumber, U extends TNumber> MaxPoolWithArgmax<T, U> maxPoolWit
    * @param options carries optional attributes values
    * @return a new instance of NthElement
    */
-  public <T extends TNumber> NthElement<T> nthElement(Operand<T> input, Operand<TInt32> n,
+  public <T extends Tensor & TNumber> NthElement<T> nthElement(Operand<T> input, Operand<TInt32> n,
       NthElement.Options... options) {
     return NthElement.create(scope, input, n, options);
   }
@@ -1525,7 +1527,7 @@ public <T extends TNumber> NthElement<T> nthElement(Operand<T> input, Operand<TI
    * @param padding The type of padding algorithm to use.
    * @return a new instance of QuantizedAvgPool
    */
-  public <T extends TType> QuantizedAvgPool<T> quantizedAvgPool(Operand<T> input,
+  public <T extends Tensor> QuantizedAvgPool<T> quantizedAvgPool(Operand<T> input,
       Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides,
       String padding) {
     return QuantizedAvgPool.create(scope, input, minInput, maxInput, ksize, strides, padding);
@@ -1566,7 +1568,7 @@ public <T extends TType> QuantizedAvgPool<T> quantizedAvgPool(Operand<T> input,
    *  needs to be multiplied with gamma.
    * @return a new instance of QuantizedBatchNormWithGlobalNormalization
    */
-  public <U extends TType, T extends TType> QuantizedBatchNormWithGlobalNormalization<U> quantizedBatchNormWithGlobalNormalization(
+  public <U extends Tensor, T extends Tensor> QuantizedBatchNormWithGlobalNormalization<U> quantizedBatchNormWithGlobalNormalization(
       Operand<T> t, Operand<TFloat32> tMin, Operand<TFloat32> tMax, Operand<T> m,
       Operand<TFloat32> mMin, Operand<TFloat32> mMax, Operand<T> v, Operand<TFloat32> vMin,
       Operand<TFloat32> vMax, Operand<T> beta, Operand<TFloat32> betaMin, Operand<TFloat32> betaMax,
@@ -1590,7 +1592,7 @@ public <U extends TType, T extends TType> QuantizedBatchNormWithGlobalNormalizat
    * @param outType
    * @return a new instance of QuantizedBiasAdd
    */
-  public <V extends TType, T extends TType, U extends TType> QuantizedBiasAdd<V> quantizedBiasAdd(
+  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedBiasAdd<V> quantizedBiasAdd(
       Operand<T> input, Operand<U> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput,
       Operand<TFloat32> minBias, Operand<TFloat32> maxBias, DataType<V> outType) {
     return QuantizedBiasAdd.create(scope, input, bias, minInput, maxInput, minBias, maxBias, outType);
@@ -1618,7 +1620,7 @@ public <V extends TType, T extends TType, U extends TType> QuantizedBiasAdd<V> q
    * @param options carries optional attributes values
    * @return a new instance of QuantizedConv2d
    */
-  public <V extends TType, T extends TType, U extends TType> QuantizedConv2d<V> quantizedConv2d(
+  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2d<V> quantizedConv2d(
       Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput,
       Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType,
       List<Long> strides, String padding, QuantizedConv2d.Options... options) {
@@ -1635,7 +1637,7 @@ public <V extends TType, T extends TType, U extends TType> QuantizedConv2d<V> qu
    * @param options carries optional attributes values
    * @return a new instance of QuantizedInstanceNorm
    */
-  public <T extends TType> QuantizedInstanceNorm<T> quantizedInstanceNorm(Operand<T> x,
+  public <T extends Tensor> QuantizedInstanceNorm<T> quantizedInstanceNorm(Operand<T> x,
       Operand<TFloat32> xMin, Operand<TFloat32> xMax, QuantizedInstanceNorm.Options... options) {
     return QuantizedInstanceNorm.create(scope, x, xMin, xMax, options);
   }
@@ -1654,7 +1656,7 @@ public <T extends TType> QuantizedInstanceNorm<T> quantizedInstanceNorm(Operand<
    * @param padding The type of padding algorithm to use.
    * @return a new instance of QuantizedMaxPool
    */
-  public <T extends TType> QuantizedMaxPool<T> quantizedMaxPool(Operand<T> input,
+  public <T extends Tensor> QuantizedMaxPool<T> quantizedMaxPool(Operand<T> input,
       Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides,
       String padding) {
     return QuantizedMaxPool.create(scope, input, minInput, maxInput, ksize, strides, padding);
@@ -1670,7 +1672,7 @@ public <T extends TType> QuantizedMaxPool<T> quantizedMaxPool(Operand<T> input,
    * @param outType
    * @return a new instance of QuantizedRelu
    */
-  public <U extends TType, T extends TType> QuantizedRelu<U> quantizedRelu(Operand<T> features,
+  public <U extends Tensor, T extends Tensor> QuantizedRelu<U> quantizedRelu(Operand<T> features,
       Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     return QuantizedRelu.create(scope, features, minFeatures, maxFeatures, outType);
   }
@@ -1685,7 +1687,7 @@ public <U extends TType, T extends TType> QuantizedRelu<U> quantizedRelu(Operand
    * @param outType
    * @return a new instance of QuantizedRelu6
    */
-  public <U extends TType, T extends TType> QuantizedRelu6<U> quantizedRelu6(Operand<T> features,
+  public <U extends Tensor, T extends Tensor> QuantizedRelu6<U> quantizedRelu6(Operand<T> features,
       Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     return QuantizedRelu6.create(scope, features, minFeatures, maxFeatures, outType);
   }
@@ -1701,7 +1703,7 @@ public <U extends TType, T extends TType> QuantizedRelu6<U> quantizedRelu6(Opera
    * @param outType
    * @return a new instance of QuantizedReluX
    */
-  public <U extends TType, T extends TType> QuantizedReluX<U> quantizedReluX(Operand<T> features,
+  public <U extends Tensor, T extends Tensor> QuantizedReluX<U> quantizedReluX(Operand<T> features,
       Operand<TFloat32> maxValue, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures,
       DataType<U> outType) {
     return QuantizedReluX.create(scope, features, maxValue, minFeatures, maxFeatures, outType);
@@ -1719,7 +1721,7 @@ public <U extends TType, T extends TType> QuantizedReluX<U> quantizedReluX(Opera
    * @param features
    * @return a new instance of Relu
    */
-  public <T extends TType> Relu<T> relu(Operand<T> features) {
+  public <T extends Tensor> Relu<T> relu(Operand<T> features) {
     return Relu.create(scope, features);
   }
 
@@ -1730,7 +1732,7 @@ public <T extends TType> Relu<T> relu(Operand<T> features) {
    * @param features
    * @return a new instance of Relu6
    */
-  public <T extends TNumber> Relu6<T> relu6(Operand<T> features) {
+  public <T extends Tensor & TNumber> Relu6<T> relu6(Operand<T> features) {
     return Relu6.create(scope, features);
   }
 
@@ -1749,7 +1751,7 @@ public <T extends TNumber> Relu6<T> relu6(Operand<T> features) {
    * @param features
    * @return a new instance of Selu
    */
-  public <T extends TNumber> Selu<T> selu(Operand<T> features) {
+  public <T extends Tensor & TNumber> Selu<T> selu(Operand<T> features) {
     return Selu.create(scope, features);
   }
 
@@ -1764,7 +1766,7 @@ public <T extends TNumber> Selu<T> selu(Operand<T> features) {
    * @param logits 2-D with shape `[batch_size, num_classes]`.
    * @return a new instance of Softmax
    */
-  public <T extends TNumber> Softmax<T> softmax(Operand<T> logits) {
+  public <T extends Tensor & TNumber> Softmax<T> softmax(Operand<T> logits) {
     return Softmax.create(scope, logits);
   }
 
@@ -1780,7 +1782,7 @@ public <T extends TNumber> Softmax<T> softmax(Operand<T> logits) {
    *  probability distribution.
    * @return a new instance of SoftmaxCrossEntropyWithLogits
    */
-  public <T extends TNumber> SoftmaxCrossEntropyWithLogits<T> softmaxCrossEntropyWithLogits(
+  public <T extends Tensor & TNumber> SoftmaxCrossEntropyWithLogits<T> softmaxCrossEntropyWithLogits(
       Operand<T> features, Operand<T> labels) {
     return SoftmaxCrossEntropyWithLogits.create(scope, features, labels);
   }
@@ -1792,7 +1794,7 @@ public <T extends TNumber> SoftmaxCrossEntropyWithLogits<T> softmaxCrossEntropyW
    * @param features
    * @return a new instance of Softsign
    */
-  public <T extends TNumber> Softsign<T> softsign(Operand<T> features) {
+  public <T extends Tensor & TNumber> Softsign<T> softsign(Operand<T> features) {
     return Softsign.create(scope, features);
   }
 
@@ -1881,8 +1883,8 @@ public <T extends TNumber> Softsign<T> softsign(Operand<T> features) {
    * @param blockSize
    * @return a new instance of SpaceToBatch
    */
-  public <T extends TType, U extends TNumber> SpaceToBatch<T> spaceToBatch(Operand<T> input,
-      Operand<U> paddings, Long blockSize) {
+  public <T extends Tensor, U extends Tensor & TNumber> SpaceToBatch<T> spaceToBatch(
+      Operand<T> input, Operand<U> paddings, Long blockSize) {
     return SpaceToBatch.create(scope, input, paddings, blockSize);
   }
 
@@ -1968,7 +1970,7 @@ public <T extends TType, U extends TNumber> SpaceToBatch<T> spaceToBatch(Operand
    * @param options carries optional attributes values
    * @return a new instance of SpaceToDepth
    */
-  public <T extends TType> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long blockSize,
+  public <T extends Tensor> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long blockSize,
       SpaceToDepth.Options... options) {
     return SpaceToDepth.create(scope, input, blockSize, options);
   }
@@ -1989,7 +1991,7 @@ public <T extends TType> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long blo
    *  This is the label for the given minibatch entry.
    * @return a new instance of SparseSoftmaxCrossEntropyWithLogits
    */
-  public <T extends TNumber, U extends TNumber> SparseSoftmaxCrossEntropyWithLogits<T> sparseSoftmaxCrossEntropyWithLogits(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSoftmaxCrossEntropyWithLogits<T> sparseSoftmaxCrossEntropyWithLogits(
       Operand<T> features, Operand<U> labels) {
     return SparseSoftmaxCrossEntropyWithLogits.create(scope, features, labels);
   }
@@ -2015,7 +2017,7 @@ public <T extends TNumber, U extends TNumber> SparseSoftmaxCrossEntropyWithLogit
    * @param options carries optional attributes values
    * @return a new instance of TopK
    */
-  public <T extends TNumber> TopK<T> topK(Operand<T> input, Operand<TInt32> k,
+  public <T extends Tensor & TNumber> TopK<T> topK(Operand<T> input, Operand<TInt32> k,
       TopK.Options... options) {
     return TopK.create(scope, input, k, options);
   }
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 fa7701af49f..fa1b27e62bd 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
@@ -395,7 +395,7 @@ public Abort abort(Abort.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of All
    */
-  public <T extends TNumber> All all(Operand<TBool> input, Operand<T> axis,
+  public <T extends Tensor & TNumber> All all(Operand<TBool> input, Operand<T> axis,
       All.Options... options) {
     return All.create(scope, input, axis, options);
   }
@@ -414,7 +414,7 @@ public <T extends TNumber> All all(Operand<TBool> input, Operand<T> axis,
    * @param options carries optional attributes values
    * @return a new instance of Any
    */
-  public <T extends TNumber> Any any(Operand<TBool> input, Operand<T> axis,
+  public <T extends Tensor & TNumber> Any any(Operand<TBool> input, Operand<T> axis,
       Any.Options... options) {
     return Any.create(scope, input, axis, options);
   }
@@ -537,7 +537,7 @@ public AssertThat assertThat(Operand<TBool> condition, Iterable<Operand<?>> data
    * @param options carries optional attributes values
    * @return a new instance of Assign
    */
-  public <T extends TType> Assign<T> assign(Operand<T> ref, Operand<T> value,
+  public <T extends Tensor> Assign<T> assign(Operand<T> ref, Operand<T> value,
       Assign.Options... options) {
     return Assign.create(scope, ref, value, options);
   }
@@ -554,7 +554,7 @@ public <T extends TType> Assign<T> assign(Operand<T> ref, Operand<T> value,
    * @param options carries optional attributes values
    * @return a new instance of AssignAdd
    */
-  public <T extends TType> AssignAdd<T> assignAdd(Operand<T> ref, Operand<T> value,
+  public <T extends Tensor> AssignAdd<T> assignAdd(Operand<T> ref, Operand<T> value,
       AssignAdd.Options... options) {
     return AssignAdd.create(scope, ref, value, options);
   }
@@ -569,7 +569,7 @@ public <T extends TType> AssignAdd<T> assignAdd(Operand<T> ref, Operand<T> value
    * @param value the value by which the variable will be incremented.
    * @return a new instance of AssignAddVariableOp
    */
-  public <T extends TType> AssignAddVariableOp assignAddVariableOp(Operand<?> resource,
+  public <T extends Tensor> AssignAddVariableOp assignAddVariableOp(Operand<?> resource,
       Operand<T> value) {
     return AssignAddVariableOp.create(scope, resource, value);
   }
@@ -586,7 +586,7 @@ public <T extends TType> AssignAddVariableOp assignAddVariableOp(Operand<?> reso
    * @param options carries optional attributes values
    * @return a new instance of AssignSub
    */
-  public <T extends TType> AssignSub<T> assignSub(Operand<T> ref, Operand<T> value,
+  public <T extends Tensor> AssignSub<T> assignSub(Operand<T> ref, Operand<T> value,
       AssignSub.Options... options) {
     return AssignSub.create(scope, ref, value, options);
   }
@@ -601,7 +601,7 @@ public <T extends TType> AssignSub<T> assignSub(Operand<T> ref, Operand<T> value
    * @param value the value by which the variable will be incremented.
    * @return a new instance of AssignSubVariableOp
    */
-  public <T extends TType> AssignSubVariableOp assignSubVariableOp(Operand<?> resource,
+  public <T extends Tensor> AssignSubVariableOp assignSubVariableOp(Operand<?> resource,
       Operand<T> value) {
     return AssignSubVariableOp.create(scope, resource, value);
   }
@@ -616,7 +616,7 @@ public <T extends TType> AssignSubVariableOp assignSubVariableOp(Operand<?> reso
    * @param value the value to set the new tensor to use.
    * @return a new instance of AssignVariableOp
    */
-  public <T extends TType> AssignVariableOp assignVariableOp(Operand<?> resource,
+  public <T extends Tensor> AssignVariableOp assignVariableOp(Operand<?> resource,
       Operand<T> value) {
     return AssignVariableOp.create(scope, resource, value);
   }
@@ -684,7 +684,7 @@ public BarrierIncompleteSize barrierIncompleteSize(Operand<TString> handle) {
    * @param componentIndex The component of the barrier elements that is being assigned.
    * @return a new instance of BarrierInsertMany
    */
-  public <T extends TType> BarrierInsertMany barrierInsertMany(Operand<TString> handle,
+  public <T extends Tensor> BarrierInsertMany barrierInsertMany(Operand<TString> handle,
       Operand<TString> keys, Operand<T> values, Long componentIndex) {
     return BarrierInsertMany.create(scope, handle, keys, values, componentIndex);
   }
@@ -799,8 +799,8 @@ public Batch batch(Iterable<Operand<?>> inTensors, Long numBatchThreads, Long ma
    * @param blockSize
    * @return a new instance of BatchToSpace
    */
-  public <T extends TType, U extends TNumber> BatchToSpace<T> batchToSpace(Operand<T> input,
-      Operand<U> crops, Long blockSize) {
+  public <T extends Tensor, U extends Tensor & TNumber> BatchToSpace<T> batchToSpace(
+      Operand<T> input, Operand<U> crops, Long blockSize) {
     return BatchToSpace.create(scope, input, crops, blockSize);
   }
 
@@ -914,7 +914,7 @@ public <T extends TType, U extends TNumber> BatchToSpace<T> batchToSpace(Operand
    *  }</pre>
    * @return a new instance of BatchToSpaceNd
    */
-  public <T extends TType, U extends TNumber, V extends TNumber> BatchToSpaceNd<T> batchToSpaceNd(
+  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> BatchToSpaceNd<T> batchToSpaceNd(
       Operand<T> input, Operand<U> blockShape, Operand<V> crops) {
     return BatchToSpaceNd.create(scope, input, blockShape, crops);
   }
@@ -978,7 +978,8 @@ public <T extends TType, U extends TNumber, V extends TNumber> BatchToSpaceNd<T>
    * @param type
    * @return a new instance of Bitcast
    */
-  public <U extends TType, T extends TType> Bitcast<U> bitcast(Operand<T> input, DataType<U> type) {
+  public <U extends Tensor, T extends Tensor> Bitcast<U> bitcast(Operand<T> input,
+      DataType<U> type) {
     return Bitcast.create(scope, input, type);
   }
 
@@ -993,7 +994,7 @@ public <U extends TType, T extends TType> Bitcast<U> bitcast(Operand<T> input, D
    * @param s1
    * @return a new instance of BroadcastDynamicShape
    */
-  public <T extends TNumber> BroadcastDynamicShape<T> broadcastDynamicShape(Operand<T> s0,
+  public <T extends Tensor & TNumber> BroadcastDynamicShape<T> broadcastDynamicShape(Operand<T> s0,
       Operand<T> s1) {
     return BroadcastDynamicShape.create(scope, s0, s1);
   }
@@ -1025,7 +1026,7 @@ public <T extends TNumber> BroadcastDynamicShape<T> broadcastDynamicShape(Operan
    * @param shape An 1-D `int` Tensor. The shape of the desired output.
    * @return a new instance of BroadcastTo
    */
-  public <T extends TType, U extends TNumber> BroadcastTo<T> broadcastTo(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> BroadcastTo<T> broadcastTo(Operand<T> input,
       Operand<U> shape) {
     return BroadcastTo.create(scope, input, shape);
   }
@@ -1048,7 +1049,8 @@ public <T extends TType, U extends TNumber> BroadcastTo<T> broadcastTo(Operand<T
    * @param boundaries A sorted list of floats gives the boundary of the buckets.
    * @return a new instance of Bucketize
    */
-  public <T extends TNumber> Bucketize bucketize(Operand<T> input, List<Float> boundaries) {
+  public <T extends Tensor & TNumber> Bucketize bucketize(Operand<T> input,
+      List<Float> boundaries) {
     return Bucketize.create(scope, input, boundaries);
   }
 
@@ -1068,7 +1070,7 @@ public <T extends TNumber> Bucketize bucketize(Operand<T> input, List<Float> bou
    *  as `t`. The maximum value to clip by.
    * @return a new instance of ClipByValue
    */
-  public <T extends TType> ClipByValue<T> clipByValue(Operand<T> t, Operand<T> clipValueMin,
+  public <T extends Tensor> ClipByValue<T> clipByValue(Operand<T> t, Operand<T> clipValueMin,
       Operand<T> clipValueMax) {
     return ClipByValue.create(scope, t, clipValueMin, clipValueMax);
   }
@@ -1083,8 +1085,8 @@ public <T extends TType> ClipByValue<T> clipByValue(Operand<T> t, Operand<T> cli
    *  range [-rank(values), rank(values)).
    * @return a new instance of Concat
    */
-  public <T extends TType, U extends TNumber> Concat<T> concat(Iterable<Operand<T>> values,
-      Operand<U> axis) {
+  public <T extends Tensor, U extends Tensor & TNumber> Concat<T> concat(
+      Iterable<Operand<T>> values, Operand<U> axis) {
     return Concat.create(scope, values, axis);
   }
 
@@ -1694,7 +1696,7 @@ public Constant<TInt64> constant(Shape shape) {
    * @param tensor a Tensor holding the constant value
    * @return a constant of the same data type as `tensor`
    */
-  public <T extends TType> Constant<T> constant(Tensor<T> tensor) {
+  public <T extends Tensor & TType> Constant<T> constant(T tensor) {
     return Constant.create(scope, tensor);
   }
 
@@ -1853,7 +1855,7 @@ public Constant<TString> constant(Charset charset, Shape shape, DataBuffer<Strin
    * @throws IllegalArgumentException If the tensor datatype or shape is not compatible with the
    *      buffer
    */
-  public <T extends TType & Tensor> Constant<T> constant(DataType<T> type, Shape shape,
+  public <T extends Tensor & TType> Constant<T> constant(DataType<T> type, Shape shape,
       ByteDataBuffer data) {
     return Constant.tensorOf(scope, type, shape, data);
   }
@@ -1896,7 +1898,7 @@ public ControlTrigger controlTrigger() {
    *  'OutOfRange' error.
    * @return a new instance of CountUpTo
    */
-  public <T extends TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long limit) {
+  public <T extends Tensor & TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long limit) {
     return CountUpTo.create(scope, ref, limit);
   }
 
@@ -1907,7 +1909,7 @@ public <T extends TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long limit) {
    * @param x The source tensor of type `T`.
    * @return a new instance of DeepCopy
    */
-  public <T extends TType> DeepCopy<T> deepCopy(Operand<T> x) {
+  public <T extends Tensor> DeepCopy<T> deepCopy(Operand<T> x) {
     return DeepCopy.create(scope, x);
   }
 
@@ -1953,7 +1955,7 @@ public DestroyResourceOp destroyResourceOp(Operand<?> resource,
    *  'TemporaryVariable' op.
    * @return a new instance of DestroyTemporaryVariable
    */
-  public <T extends TType> DestroyTemporaryVariable<T> destroyTemporaryVariable(Operand<T> ref,
+  public <T extends Tensor> DestroyTemporaryVariable<T> destroyTemporaryVariable(Operand<T> ref,
       String varName) {
     return DestroyTemporaryVariable.create(scope, ref, varName);
   }
@@ -2001,7 +2003,7 @@ public <T extends TType> DestroyTemporaryVariable<T> destroyTemporaryVariable(Op
    * @param numPartitions The number of partitions to output.
    * @return a new instance of DynamicPartition
    */
-  public <T extends TType> DynamicPartition<T> dynamicPartition(Operand<T> data,
+  public <T extends Tensor> DynamicPartition<T> dynamicPartition(Operand<T> data,
       Operand<TInt32> partitions, Long numPartitions) {
     return DynamicPartition.create(scope, data, partitions, numPartitions);
   }
@@ -2069,7 +2071,7 @@ public <T extends TType> DynamicPartition<T> dynamicPartition(Operand<T> data,
    * @param data
    * @return a new instance of DynamicStitch
    */
-  public <T extends TType> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32>> indices,
+  public <T extends Tensor> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32>> indices,
       Iterable<Operand<T>> data) {
     return DynamicStitch.create(scope, indices, data);
   }
@@ -2098,7 +2100,7 @@ public <T extends TType> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32>
    * @param options carries optional attributes values
    * @return a new instance of EditDistance
    */
-  public <T extends TType> EditDistance editDistance(Operand<TInt64> hypothesisIndices,
+  public <T extends Tensor> 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);
@@ -2115,7 +2117,7 @@ public <T extends TType> EditDistance editDistance(Operand<TInt64> hypothesisInd
    * @param options carries optional attributes values
    * @return a new instance of Empty
    */
-  public <T extends TType> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtype,
+  public <T extends Tensor> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtype,
       Empty.Options... options) {
     return Empty.create(scope, shape, dtype, options);
   }
@@ -2135,7 +2137,7 @@ public <T extends TType> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtype
    * @param elementDtype
    * @return a new instance of EmptyTensorList
    */
-  public <T extends TNumber, U extends TType> EmptyTensorList emptyTensorList(
+  public <T extends Tensor & TNumber, U extends Tensor> EmptyTensorList emptyTensorList(
       Operand<T> elementShape, Operand<TInt32> maxNumElements, DataType<U> elementDtype) {
     return EmptyTensorList.create(scope, elementShape, maxNumElements, elementDtype);
   }
@@ -2151,7 +2153,7 @@ public <T extends TNumber, U extends TType> EmptyTensorList emptyTensorList(
    * @param shape The expected (possibly partially specified) shape of the input tensor.
    * @return a new instance of EnsureShape
    */
-  public <T extends TType> EnsureShape<T> ensureShape(Operand<T> input, Shape shape) {
+  public <T extends Tensor> EnsureShape<T> ensureShape(Operand<T> input, Shape shape) {
     return EnsureShape.create(scope, input, shape);
   }
 
@@ -2194,7 +2196,7 @@ public <T extends TType> EnsureShape<T> ensureShape(Operand<T> input, Shape shap
    *  `[-rank(input) - 1, rank(input)]`.
    * @return a new instance of ExpandDims
    */
-  public <T extends TType, U extends TNumber> ExpandDims<T> expandDims(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> ExpandDims<T> expandDims(Operand<T> input,
       Operand<U> axis) {
     return ExpandDims.create(scope, input, axis);
   }
@@ -2216,7 +2218,7 @@ public <T extends TType, U extends TNumber> ExpandDims<T> expandDims(Operand<T>
    *  }</pre>
    * @return a new instance of ExtractVolumePatches
    */
-  public <T extends TNumber> ExtractVolumePatches<T> extractVolumePatches(Operand<T> input,
+  public <T extends Tensor & TNumber> ExtractVolumePatches<T> extractVolumePatches(Operand<T> input,
       List<Long> ksizes, List<Long> strides, String padding) {
     return ExtractVolumePatches.create(scope, input, ksizes, strides, padding);
   }
@@ -2255,7 +2257,8 @@ public <T extends TNumber> ExtractVolumePatches<T> extractVolumePatches(Operand<
    * @end_compatibility
    * @return a new instance of Fill
    */
-  public <U extends TType, T extends TNumber> Fill<U> fill(Operand<T> dims, Operand<U> value) {
+  public <U extends Tensor, T extends Tensor & TNumber> Fill<U> fill(Operand<T> dims,
+      Operand<U> value) {
     return Fill.create(scope, dims, value);
   }
 
@@ -2296,7 +2299,7 @@ public <U extends TType, T extends TNumber> Fill<U> fill(Operand<T> dims, Operan
    *  `farmhash::fingerprint64`.
    * @return a new instance of Fingerprint
    */
-  public <T extends TType> Fingerprint fingerprint(Operand<T> data, Operand<TString> method) {
+  public <T extends Tensor> Fingerprint fingerprint(Operand<T> data, Operand<TString> method) {
     return Fingerprint.create(scope, data, method);
   }
 
@@ -2338,8 +2341,8 @@ public <T extends TType> Fingerprint fingerprint(Operand<T> data, Operand<TStrin
    * @param options carries optional attributes values
    * @return a new instance of Gather
    */
-  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) {
+  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Gather<T> gather(
+      Operand<T> params, Operand<U> indices, Operand<V> axis, Gather.Options... options) {
     return Gather.create(scope, params, indices, axis, options);
   }
 
@@ -2444,7 +2447,7 @@ public <T extends TType, U extends TNumber, V extends TNumber> Gather<T> gather(
    * @param indices Index tensor.
    * @return a new instance of GatherNd
    */
-  public <T extends TType, U extends TNumber> GatherNd<T> gatherNd(Operand<T> params,
+  public <T extends Tensor, U extends Tensor & TNumber> GatherNd<T> gatherNd(Operand<T> params,
       Operand<U> indices) {
     return GatherNd.create(scope, params, indices);
   }
@@ -2455,7 +2458,7 @@ public <T extends TType, U extends TNumber> GatherNd<T> gatherNd(Operand<T> para
    * @param value The tensor to be stored.
    * @return a new instance of GetSessionHandle
    */
-  public <T extends TType> GetSessionHandle getSessionHandle(Operand<T> value) {
+  public <T extends Tensor> GetSessionHandle getSessionHandle(Operand<T> value) {
     return GetSessionHandle.create(scope, value);
   }
 
@@ -2467,7 +2470,7 @@ public <T extends TType> GetSessionHandle getSessionHandle(Operand<T> value) {
    * @param dtype The type of the output value.
    * @return a new instance of GetSessionTensor
    */
-  public <T extends TType> GetSessionTensor<T> getSessionTensor(Operand<TString> handle,
+  public <T extends Tensor> GetSessionTensor<T> getSessionTensor(Operand<TString> handle,
       DataType<T> dtype) {
     return GetSessionTensor.create(scope, handle, dtype);
   }
@@ -2532,7 +2535,7 @@ public Gradients gradients(Operand<?> y, Iterable<? extends Operand<?>> x,
    * @param input
    * @return a new instance of GuaranteeConst
    */
-  public <T extends TType> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
+  public <T extends Tensor> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
     return GuaranteeConst.create(scope, input);
   }
 
@@ -2548,7 +2551,7 @@ public <T extends TType> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of HashTable
    */
-  public <T extends TType, U extends TType> HashTable hashTable(DataType<T> keyDtype,
+  public <T extends Tensor, U extends Tensor> HashTable hashTable(DataType<T> keyDtype,
       DataType<U> valueDtype, HashTable.Options... options) {
     return HashTable.create(scope, keyDtype, valueDtype, options);
   }
@@ -2579,8 +2582,8 @@ public <T extends TType, U extends TType> HashTable hashTable(DataType<T> keyDty
    * @param nbins Scalar `int32 Tensor`.  Number of histogram bins.
    * @return a new instance of HistogramFixedWidth
    */
-  public <T extends TNumber> HistogramFixedWidth<TInt32> histogramFixedWidth(Operand<T> values,
-      Operand<T> valueRange, Operand<TInt32> nbins) {
+  public <T extends Tensor & TNumber> HistogramFixedWidth<TInt32> histogramFixedWidth(
+      Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins) {
     return HistogramFixedWidth.create(scope, values, valueRange, nbins);
   }
 
@@ -2611,7 +2614,7 @@ public <T extends TNumber> HistogramFixedWidth<TInt32> histogramFixedWidth(Opera
    * @param dtype
    * @return a new instance of HistogramFixedWidth
    */
-  public <U extends TNumber, T extends TNumber> HistogramFixedWidth<U> histogramFixedWidth(
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> HistogramFixedWidth<U> histogramFixedWidth(
       Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins, DataType<U> dtype) {
     return HistogramFixedWidth.create(scope, values, valueRange, nbins, dtype);
   }
@@ -2623,7 +2626,7 @@ public <U extends TNumber, T extends TNumber> HistogramFixedWidth<U> histogramFi
    * @param input
    * @return a new instance of Identity
    */
-  public <T extends TType> Identity<T> identity(Operand<T> input) {
+  public <T extends Tensor> Identity<T> identity(Operand<T> input) {
     return Identity.create(scope, input);
   }
 
@@ -2662,7 +2665,7 @@ public IdentityN identityN(Iterable<Operand<?>> input) {
    *  NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
    * @return a new instance of ImmutableConst
    */
-  public <T extends TType> ImmutableConst<T> immutableConst(DataType<T> dtype, Shape shape,
+  public <T extends Tensor> ImmutableConst<T> immutableConst(DataType<T> dtype, Shape shape,
       String memoryRegionName) {
     return ImmutableConst.create(scope, dtype, shape, memoryRegionName);
   }
@@ -2752,8 +2755,8 @@ public void initAdd(Op initializer) {
    * @param values Values of type Tval.
    * @return a new instance of InitializeTable
    */
-  public <T extends TType, U extends TType> InitializeTable initializeTable(Operand<?> tableHandle,
-      Operand<T> keys, Operand<U> values) {
+  public <T extends Tensor, U extends Tensor> InitializeTable initializeTable(
+      Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     return InitializeTable.create(scope, tableHandle, keys, values);
   }
 
@@ -2796,7 +2799,8 @@ public InitializeTableFromTextFile initializeTableFromTextFile(Operand<?> tableH
    * @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> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public <T extends Tensor> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32> i,
+      Operand<T> v) {
     return InplaceAdd.create(scope, x, i, v);
   }
 
@@ -2811,7 +2815,8 @@ public <T extends TType> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32>
    * @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> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public <T extends Tensor> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32> i,
+      Operand<T> v) {
     return InplaceSub.create(scope, x, i, v);
   }
 
@@ -2826,7 +2831,7 @@ public <T extends TType> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32>
    * @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> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<TInt32> i,
+  public <T extends Tensor> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<TInt32> i,
       Operand<T> v) {
     return InplaceUpdate.create(scope, x, i, v);
   }
@@ -2839,7 +2844,7 @@ public <T extends TType> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<TI
    * @param ref Should be from a `Variable` node. May be uninitialized.
    * @return a new instance of IsVariableInitialized
    */
-  public <T extends TType> IsVariableInitialized isVariableInitialized(Operand<T> ref) {
+  public <T extends Tensor> IsVariableInitialized isVariableInitialized(Operand<T> ref) {
     return IsVariableInitialized.create(scope, ref);
   }
 
@@ -2861,8 +2866,8 @@ public <T extends TType> IsVariableInitialized isVariableInitialized(Operand<T>
    * @param num 0-D tensor. Number of values to generate.
    * @return a new instance of LinSpace
    */
-  public <T extends TNumber, U extends TNumber> LinSpace<T> linSpace(Operand<T> start,
-      Operand<T> stop, Operand<U> num) {
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> LinSpace<T> linSpace(
+      Operand<T> start, Operand<T> stop, Operand<U> num) {
     return LinSpace.create(scope, start, stop, num);
   }
 
@@ -2876,7 +2881,7 @@ public <T extends TNumber, U extends TNumber> LinSpace<T> linSpace(Operand<T> st
    * @param Tvalues
    * @return a new instance of LookupTableExport
    */
-  public <T extends TType, U extends TType> LookupTableExport<T, U> lookupTableExport(
+  public <T extends Tensor, U extends Tensor> LookupTableExport<T, U> lookupTableExport(
       Operand<?> tableHandle, DataType<T> Tkeys, DataType<U> Tvalues) {
     return LookupTableExport.create(scope, tableHandle, Tkeys, Tvalues);
   }
@@ -2896,7 +2901,7 @@ public <T extends TType, U extends TType> LookupTableExport<T, U> lookupTableExp
    * @param defaultValue
    * @return a new instance of LookupTableFind
    */
-  public <U extends TType, T extends TType> LookupTableFind<U> lookupTableFind(
+  public <U extends Tensor, T extends Tensor> LookupTableFind<U> lookupTableFind(
       Operand<?> tableHandle, Operand<T> keys, Operand<U> defaultValue) {
     return LookupTableFind.create(scope, tableHandle, keys, defaultValue);
   }
@@ -2912,7 +2917,7 @@ public <U extends TType, T extends TType> LookupTableFind<U> lookupTableFind(
    * @param values Values to associate with keys.
    * @return a new instance of LookupTableImport
    */
-  public <T extends TType, U extends TType> LookupTableImport lookupTableImport(
+  public <T extends Tensor, U extends Tensor> LookupTableImport lookupTableImport(
       Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     return LookupTableImport.create(scope, tableHandle, keys, values);
   }
@@ -2928,7 +2933,7 @@ public <T extends TType, U extends TType> LookupTableImport lookupTableImport(
    * @param values Values to associate with keys.
    * @return a new instance of LookupTableInsert
    */
-  public <T extends TType, U extends TType> LookupTableInsert lookupTableInsert(
+  public <T extends Tensor, U extends Tensor> LookupTableInsert lookupTableInsert(
       Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     return LookupTableInsert.create(scope, tableHandle, keys, values);
   }
@@ -3071,8 +3076,8 @@ public MapUnstageNoKey mapUnstageNoKey(Operand<TInt32> indices, List<DataType<?>
    * @param options carries optional attributes values
    * @return a new instance of Max
    */
-  public <T extends TType, U extends TNumber> Max<T> max(Operand<T> input, Operand<U> axis,
-      Max.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> Max<T> max(Operand<T> input,
+      Operand<U> axis, Max.Options... options) {
     return Max.create(scope, input, axis, options);
   }
 
@@ -3089,7 +3094,7 @@ public <T extends TType, U extends TNumber> Max<T> max(Operand<T> input, Operand
    * @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) {
+  public <T extends Tensor> Merge<T> merge(Iterable<Operand<T>> inputs) {
     return Merge.create(scope, inputs);
   }
 
@@ -3108,8 +3113,8 @@ public <T extends TType> Merge<T> merge(Iterable<Operand<T>> inputs) {
    * @param options carries optional attributes values
    * @return a new instance of Min
    */
-  public <T extends TType, U extends TNumber> Min<T> min(Operand<T> input, Operand<U> axis,
-      Min.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> Min<T> min(Operand<T> input,
+      Operand<U> axis, Min.Options... options) {
     return Min.create(scope, input, axis, options);
   }
 
@@ -3152,7 +3157,7 @@ public <T extends TType, U extends TNumber> Min<T> min(Operand<T> input, Operand
    *  it is `[1, 2, 3, 3, 2]` in symmetric mode.
    * @return a new instance of MirrorPad
    */
-  public <T extends TType, U extends TNumber> MirrorPad<T> mirrorPad(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> MirrorPad<T> mirrorPad(Operand<T> input,
       Operand<U> paddings, String mode) {
     return MirrorPad.create(scope, input, paddings, mode);
   }
@@ -3214,7 +3219,7 @@ public MlirPassthroughOp mlirPassthroughOp(Iterable<Operand<?>> inputs, String m
    * @param options carries optional attributes values
    * @return a new instance of MutableDenseHashTable
    */
-  public <T extends TType, U extends TType> MutableDenseHashTable mutableDenseHashTable(
+  public <T extends Tensor, U extends Tensor> MutableDenseHashTable mutableDenseHashTable(
       Operand<T> emptyKey, Operand<T> deletedKey, DataType<U> valueDtype,
       MutableDenseHashTable.Options... options) {
     return MutableDenseHashTable.create(scope, emptyKey, deletedKey, valueDtype, options);
@@ -3232,8 +3237,8 @@ public <T extends TType, U extends TType> MutableDenseHashTable mutableDenseHash
    * @param options carries optional attributes values
    * @return a new instance of MutableHashTable
    */
-  public <T extends TType, U extends TType> MutableHashTable mutableHashTable(DataType<T> keyDtype,
-      DataType<U> valueDtype, MutableHashTable.Options... options) {
+  public <T extends Tensor, U extends Tensor> MutableHashTable mutableHashTable(
+      DataType<T> keyDtype, DataType<U> valueDtype, MutableHashTable.Options... options) {
     return MutableHashTable.create(scope, keyDtype, valueDtype, options);
   }
 
@@ -3249,7 +3254,7 @@ public <T extends TType, U extends TType> MutableHashTable mutableHashTable(Data
    * @param options carries optional attributes values
    * @return a new instance of MutableHashTableOfTensors
    */
-  public <T extends TType, U extends TType> MutableHashTableOfTensors mutableHashTableOfTensors(
+  public <T extends Tensor, U extends Tensor> MutableHashTableOfTensors mutableHashTableOfTensors(
       DataType<T> keyDtype, DataType<U> valueDtype, MutableHashTableOfTensors.Options... options) {
     return MutableHashTableOfTensors.create(scope, keyDtype, valueDtype, options);
   }
@@ -3317,7 +3322,7 @@ public MutexLock mutexLock(Operand<?> mutex) {
    * @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) {
+  public <T extends Tensor> NextIteration<T> nextIteration(Operand<T> data) {
     return NextIteration.create(scope, data);
   }
 
@@ -3421,7 +3426,7 @@ public NoOp noOp() {
    * @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,
+  public <U extends Tensor, T extends Tensor & 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);
   }
@@ -3433,7 +3438,7 @@ public <U extends TType, T extends TNumber> OneHot<U> oneHot(Operand<T> indices,
    * @param x a tensor of type T.
    * @return a new instance of OnesLike
    */
-  public <T extends TType> OnesLike<T> onesLike(Operand<T> x) {
+  public <T extends Tensor> OnesLike<T> onesLike(Operand<T> x) {
     return OnesLike.create(scope, x);
   }
 
@@ -3575,8 +3580,8 @@ public OrderedMapUnstageNoKey orderedMapUnstageNoKey(Operand<TInt32> indices,
    * @param constantValues
    * @return a new instance of Pad
    */
-  public <T extends TType, U extends TNumber> Pad<T> pad(Operand<T> input, Operand<U> paddings,
-      Operand<T> constantValues) {
+  public <T extends Tensor, U extends Tensor & TNumber> Pad<T> pad(Operand<T> input,
+      Operand<U> paddings, Operand<T> constantValues) {
     return Pad.create(scope, input, paddings, constantValues);
   }
 
@@ -3605,7 +3610,7 @@ public <T extends TType, U extends TNumber> Pad<T> pad(Operand<T> input, Operand
    *  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,
+  public <T extends Tensor> ParallelConcat<T> parallelConcat(Iterable<Operand<T>> values,
       Shape shape) {
     return ParallelConcat.create(scope, values, shape);
   }
@@ -3672,7 +3677,7 @@ public <T extends TType> ParallelConcat<T> parallelConcat(Iterable<Operand<T>> v
    * @param data
    * @return a new instance of ParallelDynamicStitch
    */
-  public <T extends TType> ParallelDynamicStitch<T> parallelDynamicStitch(
+  public <T extends Tensor> ParallelDynamicStitch<T> parallelDynamicStitch(
       Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
     return ParallelDynamicStitch.create(scope, indices, data);
   }
@@ -3689,7 +3694,7 @@ public <T extends TType> ParallelDynamicStitch<T> parallelDynamicStitch(
    * @param options carries optional attributes values
    * @return a new instance of Placeholder
    */
-  public <T extends TType> Placeholder<T> placeholder(DataType<T> dtype,
+  public <T extends Tensor> Placeholder<T> placeholder(DataType<T> dtype,
       Placeholder.Options... options) {
     return Placeholder.create(scope, dtype, options);
   }
@@ -3702,7 +3707,7 @@ public <T extends TType> Placeholder<T> placeholder(DataType<T> dtype,
    * @param shape The (possibly partial) shape of the tensor.
    * @return a new instance of PlaceholderWithDefault
    */
-  public <T extends TType> PlaceholderWithDefault<T> placeholderWithDefault(Operand<T> input,
+  public <T extends Tensor> PlaceholderWithDefault<T> placeholderWithDefault(Operand<T> input,
       Shape shape) {
     return PlaceholderWithDefault.create(scope, input, shape);
   }
@@ -3735,8 +3740,8 @@ public Print print(Operand<TString> input, Print.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of Prod
    */
-  public <T extends TType, U extends TNumber> Prod<T> prod(Operand<T> input, Operand<U> axis,
-      Prod.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> Prod<T> prod(Operand<T> input,
+      Operand<U> axis, Prod.Options... options) {
     return Prod.create(scope, input, axis, options);
   }
 
@@ -3752,7 +3757,7 @@ public <T extends TType, U extends TNumber> Prod<T> prod(Operand<T> input, Opera
    * @param inputMax The maximum value of the input.
    * @return a new instance of QuantizedReshape
    */
-  public <T extends TType, U extends TNumber> QuantizedReshape<T> quantizedReshape(
+  public <T extends Tensor, U extends Tensor & TNumber> QuantizedReshape<T> quantizedReshape(
       Operand<T> tensor, Operand<U> shape, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
     return QuantizedReshape.create(scope, tensor, shape, inputMin, inputMax);
   }
@@ -3777,7 +3782,8 @@ public <T extends TType, U extends TNumber> QuantizedReshape<T> quantizedReshape
    * @param delta 0-D (scalar). Optional. Default is 1. Number that increments `start`.
    * @return a new instance of Range
    */
-  public <T extends TNumber> Range<T> range(Operand<T> start, Operand<T> limit, Operand<T> delta) {
+  public <T extends Tensor & TNumber> Range<T> range(Operand<T> start, Operand<T> limit,
+      Operand<T> delta) {
     return Range.create(scope, start, limit, delta);
   }
 
@@ -3799,7 +3805,7 @@ public <T extends TNumber> Range<T> range(Operand<T> start, Operand<T> limit, Op
    * @param input
    * @return a new instance of Rank
    */
-  public <T extends TType> Rank rank(Operand<T> input) {
+  public <T extends Tensor> Rank rank(Operand<T> input) {
     return Rank.create(scope, input);
   }
 
@@ -3818,7 +3824,7 @@ public <T extends TType> Rank rank(Operand<T> input) {
    * @param dtype the dtype of the value.
    * @return a new instance of ReadVariableOp
    */
-  public <T extends TType> ReadVariableOp<T> readVariableOp(Operand<?> resource,
+  public <T extends Tensor> ReadVariableOp<T> readVariableOp(Operand<?> resource,
       DataType<T> dtype) {
     return ReadVariableOp.create(scope, resource, dtype);
   }
@@ -3837,7 +3843,7 @@ public <T extends TType> ReadVariableOp<T> readVariableOp(Operand<?> resource,
    * @param options carries optional attributes values
    * @return a new instance of ReduceAll
    */
-  public <T extends TNumber> ReduceAll reduceAll(Operand<TBool> input, Operand<T> axis,
+  public <T extends Tensor & TNumber> ReduceAll reduceAll(Operand<TBool> input, Operand<T> axis,
       ReduceAll.Options... options) {
     return ReduceAll.create(scope, input, axis, options);
   }
@@ -3856,7 +3862,7 @@ public <T extends TNumber> ReduceAll reduceAll(Operand<TBool> input, Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ReduceAny
    */
-  public <T extends TNumber> ReduceAny reduceAny(Operand<TBool> input, Operand<T> axis,
+  public <T extends Tensor & TNumber> ReduceAny reduceAny(Operand<TBool> input, Operand<T> axis,
       ReduceAny.Options... options) {
     return ReduceAny.create(scope, input, axis, options);
   }
@@ -3876,7 +3882,7 @@ public <T extends TNumber> ReduceAny reduceAny(Operand<TBool> input, Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ReduceMax
    */
-  public <T extends TType, U extends TNumber> ReduceMax<T> reduceMax(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> ReduceMax<T> reduceMax(Operand<T> input,
       Operand<U> axis, ReduceMax.Options... options) {
     return ReduceMax.create(scope, input, axis, options);
   }
@@ -3896,7 +3902,7 @@ public <T extends TType, U extends TNumber> ReduceMax<T> reduceMax(Operand<T> in
    * @param options carries optional attributes values
    * @return a new instance of ReduceMin
    */
-  public <T extends TType, U extends TNumber> ReduceMin<T> reduceMin(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> ReduceMin<T> reduceMin(Operand<T> input,
       Operand<U> axis, ReduceMin.Options... options) {
     return ReduceMin.create(scope, input, axis, options);
   }
@@ -3916,7 +3922,7 @@ public <T extends TType, U extends TNumber> ReduceMin<T> reduceMin(Operand<T> in
    * @param options carries optional attributes values
    * @return a new instance of ReduceProd
    */
-  public <T extends TType, U extends TNumber> ReduceProd<T> reduceProd(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> ReduceProd<T> reduceProd(Operand<T> input,
       Operand<U> axis, ReduceProd.Options... options) {
     return ReduceProd.create(scope, input, axis, options);
   }
@@ -3936,7 +3942,7 @@ public <T extends TType, U extends TNumber> ReduceProd<T> reduceProd(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ReduceSum
    */
-  public <T extends TType, U extends TNumber> ReduceSum<T> reduceSum(Operand<T> input,
+  public <T extends Tensor, U extends Tensor & TNumber> ReduceSum<T> reduceSum(Operand<T> input,
       Operand<U> axis, ReduceSum.Options... options) {
     return ReduceSum.create(scope, input, axis, options);
   }
@@ -3948,7 +3954,7 @@ public <T extends TType, U extends TNumber> ReduceSum<T> reduceSum(Operand<T> in
    * @param data The tensor to be made available to the next iteration.
    * @return a new instance of RefNextIteration
    */
-  public <T extends TType> RefNextIteration<T> refNextIteration(Operand<T> data) {
+  public <T extends Tensor> RefNextIteration<T> refNextIteration(Operand<T> data) {
     return RefNextIteration.create(scope, data);
   }
 
@@ -3960,7 +3966,7 @@ public <T extends TType> RefNextIteration<T> refNextIteration(Operand<T> data) {
    * @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> RefSelect<T> refSelect(Operand<TInt32> index,
+  public <T extends Tensor> RefSelect<T> refSelect(Operand<TInt32> index,
       Iterable<Operand<T>> inputs) {
     return RefSelect.create(scope, index, inputs);
   }
@@ -3978,7 +3984,7 @@ public <T extends TType> RefSelect<T> refSelect(Operand<TInt32> index,
    * @param pred A scalar that specifies which output port will receive data.
    * @return a new instance of RefSwitch
    */
-  public <T extends TType> RefSwitch<T> refSwitch(Operand<T> data, Operand<TBool> pred) {
+  public <T extends Tensor> RefSwitch<T> refSwitch(Operand<T> data, Operand<TBool> pred) {
     return RefSwitch.create(scope, data, pred);
   }
 
@@ -4071,7 +4077,7 @@ public RemoteFusedGraphExecute remoteFusedGraphExecute(Iterable<Operand<?>> inpu
    * @param shape Defines the shape of the output tensor.
    * @return a new instance of Reshape
    */
-  public <T extends TType, U extends TNumber> Reshape<T> reshape(Operand<T> tensor,
+  public <T extends Tensor, U extends Tensor & TNumber> Reshape<T> reshape(Operand<T> tensor,
       Operand<U> shape) {
     return Reshape.create(scope, tensor, shape);
   }
@@ -4086,8 +4092,8 @@ public <T extends TType, U extends TNumber> Reshape<T> reshape(Operand<T> tensor
    * @param T
    * @return a new instance of ResourceCountUpTo
    */
-  public <T extends TNumber> ResourceCountUpTo<T> resourceCountUpTo(Operand<?> resource, Long limit,
-      DataType<T> T) {
+  public <T extends Tensor & TNumber> ResourceCountUpTo<T> resourceCountUpTo(Operand<?> resource,
+      Long limit, DataType<T> T) {
     return ResourceCountUpTo.create(scope, resource, limit, T);
   }
 
@@ -4114,8 +4120,9 @@ public <T extends TNumber> ResourceCountUpTo<T> resourceCountUpTo(Operand<?> res
    * @param options carries optional attributes values
    * @return a new instance of ResourceGather
    */
-  public <U extends TType, T extends TNumber> ResourceGather<U> resourceGather(Operand<?> resource,
-      Operand<T> indices, DataType<U> dtype, ResourceGather.Options... options) {
+  public <U extends Tensor, T extends Tensor & TNumber> ResourceGather<U> resourceGather(
+      Operand<?> resource, Operand<T> indices, DataType<U> dtype,
+      ResourceGather.Options... options) {
     return ResourceGather.create(scope, resource, indices, dtype, options);
   }
 
@@ -4127,7 +4134,7 @@ public <U extends TType, T extends TNumber> ResourceGather<U> resourceGather(Ope
    * @param dtype
    * @return a new instance of ResourceGatherNd
    */
-  public <U extends TType, T extends TNumber> ResourceGatherNd<U> resourceGatherNd(
+  public <U extends Tensor, T extends Tensor & TNumber> ResourceGatherNd<U> resourceGatherNd(
       Operand<?> resource, Operand<T> indices, DataType<U> dtype) {
     return ResourceGatherNd.create(scope, resource, indices, dtype);
   }
@@ -4160,7 +4167,7 @@ public <U extends TType, T extends TNumber> ResourceGatherNd<U> resourceGatherNd
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterAdd
    */
-  public <T extends TNumber, U extends TType> ResourceScatterAdd resourceScatterAdd(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterAdd resourceScatterAdd(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterAdd.create(scope, resource, indices, updates);
   }
@@ -4193,7 +4200,7 @@ public <T extends TNumber, U extends TType> ResourceScatterAdd resourceScatterAd
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterDiv
    */
-  public <T extends TNumber, U extends TType> ResourceScatterDiv resourceScatterDiv(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterDiv resourceScatterDiv(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterDiv.create(scope, resource, indices, updates);
   }
@@ -4226,7 +4233,7 @@ public <T extends TNumber, U extends TType> ResourceScatterDiv resourceScatterDi
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterMax
    */
-  public <T extends TNumber, U extends TType> ResourceScatterMax resourceScatterMax(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMax resourceScatterMax(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterMax.create(scope, resource, indices, updates);
   }
@@ -4259,7 +4266,7 @@ public <T extends TNumber, U extends TType> ResourceScatterMax resourceScatterMa
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterMin
    */
-  public <T extends TNumber, U extends TType> ResourceScatterMin resourceScatterMin(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMin resourceScatterMin(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterMin.create(scope, resource, indices, updates);
   }
@@ -4292,7 +4299,7 @@ public <T extends TNumber, U extends TType> ResourceScatterMin resourceScatterMi
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterMul
    */
-  public <T extends TNumber, U extends TType> ResourceScatterMul resourceScatterMul(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMul resourceScatterMul(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterMul.create(scope, resource, indices, updates);
   }
@@ -4338,7 +4345,7 @@ public <T extends TNumber, U extends TType> ResourceScatterMul resourceScatterMu
    * @param options carries optional attributes values
    * @return a new instance of ResourceScatterNdAdd
    */
-  public <T extends TNumber, U extends TType> ResourceScatterNdAdd resourceScatterNdAdd(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdAdd resourceScatterNdAdd(
       Operand<?> ref, Operand<T> indices, Operand<U> updates,
       ResourceScatterNdAdd.Options... options) {
     return ResourceScatterNdAdd.create(scope, ref, indices, updates, options);
@@ -4385,7 +4392,7 @@ public <T extends TNumber, U extends TType> ResourceScatterNdAdd resourceScatter
    * @param options carries optional attributes values
    * @return a new instance of ResourceScatterNdSub
    */
-  public <T extends TNumber, U extends TType> ResourceScatterNdSub resourceScatterNdSub(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdSub resourceScatterNdSub(
       Operand<?> ref, Operand<T> indices, Operand<U> updates,
       ResourceScatterNdSub.Options... options) {
     return ResourceScatterNdSub.create(scope, ref, indices, updates, options);
@@ -4434,7 +4441,7 @@ public <T extends TNumber, U extends TType> ResourceScatterNdSub resourceScatter
    * @param options carries optional attributes values
    * @return a new instance of ResourceScatterNdUpdate
    */
-  public <T extends TNumber, U extends TType> ResourceScatterNdUpdate resourceScatterNdUpdate(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdUpdate resourceScatterNdUpdate(
       Operand<?> ref, Operand<T> indices, Operand<U> updates,
       ResourceScatterNdUpdate.Options... options) {
     return ResourceScatterNdUpdate.create(scope, ref, indices, updates, options);
@@ -4468,7 +4475,7 @@ public <T extends TNumber, U extends TType> ResourceScatterNdUpdate resourceScat
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterSub
    */
-  public <T extends TNumber, U extends TType> ResourceScatterSub resourceScatterSub(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterSub resourceScatterSub(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterSub.create(scope, resource, indices, updates);
   }
@@ -4492,7 +4499,7 @@ public <T extends TNumber, U extends TType> ResourceScatterSub resourceScatterSu
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterUpdate
    */
-  public <T extends TNumber, U extends TType> ResourceScatterUpdate resourceScatterUpdate(
+  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterUpdate resourceScatterUpdate(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterUpdate.create(scope, resource, indices, updates);
   }
@@ -4515,7 +4522,7 @@ public <T extends TNumber, U extends TType> ResourceScatterUpdate resourceScatte
    * @param options carries optional attributes values
    * @return a new instance of ResourceStridedSliceAssign
    */
-  public <T extends TNumber, U extends TType> ResourceStridedSliceAssign resourceStridedSliceAssign(
+  public <T extends Tensor & TNumber, U extends Tensor> 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);
@@ -4576,7 +4583,7 @@ public <T extends TNumber, U extends TType> ResourceStridedSliceAssign resourceS
    *  `[-rank(tensor), rank(tensor))`.
    * @return a new instance of Reverse
    */
-  public <T extends TType, U extends TNumber> Reverse<T> reverse(Operand<T> tensor,
+  public <T extends Tensor, U extends Tensor & TNumber> Reverse<T> reverse(Operand<T> tensor,
       Operand<U> axis) {
     return Reverse.create(scope, tensor, axis);
   }
@@ -4644,8 +4651,8 @@ public <T extends TType, U extends TNumber> Reverse<T> reverse(Operand<T> tensor
    * @param options carries optional attributes values
    * @return a new instance of ReverseSequence
    */
-  public <T extends TType, U extends TNumber> ReverseSequence<T> reverseSequence(Operand<T> input,
-      Operand<U> seqLengths, Long seqDim, ReverseSequence.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> ReverseSequence<T> reverseSequence(
+      Operand<T> input, Operand<U> seqLengths, Long seqDim, ReverseSequence.Options... options) {
     return ReverseSequence.create(scope, input, seqLengths, seqDim, options);
   }
 
@@ -4684,8 +4691,8 @@ public <T extends TType, U extends TNumber> ReverseSequence<T> reverseSequence(O
    *  axis.
    * @return a new instance of Roll
    */
-  public <T extends TType, U extends TNumber, V extends TNumber> Roll<T> roll(Operand<T> input,
-      Operand<U> shift, Operand<V> axis) {
+  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Roll<T> roll(
+      Operand<T> input, Operand<U> shift, Operand<V> axis) {
     return Roll.create(scope, input, shift, axis);
   }
 
@@ -4786,7 +4793,7 @@ public Rpc rpc(Operand<TString> address, Operand<TString> method, Operand<TStrin
    * @param options carries optional attributes values
    * @return a new instance of ScatterAdd
    */
-  public <T extends TType, U extends TNumber> ScatterAdd<T> scatterAdd(Operand<T> ref,
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterAdd<T> scatterAdd(Operand<T> ref,
       Operand<U> indices, Operand<T> updates, ScatterAdd.Options... options) {
     return ScatterAdd.create(scope, ref, indices, updates, options);
   }
@@ -4820,7 +4827,7 @@ public <T extends TType, U extends TNumber> ScatterAdd<T> scatterAdd(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ScatterDiv
    */
-  public <T extends TType, U extends TNumber> ScatterDiv<T> scatterDiv(Operand<T> ref,
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterDiv<T> scatterDiv(Operand<T> ref,
       Operand<U> indices, Operand<T> updates, ScatterDiv.Options... options) {
     return ScatterDiv.create(scope, ref, indices, updates, options);
   }
@@ -4858,8 +4865,8 @@ public <T extends TType, U extends TNumber> ScatterDiv<T> scatterDiv(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ScatterMax
    */
-  public <T extends TNumber, U extends TNumber> ScatterMax<T> scatterMax(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterMax.Options... options) {
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMax<T> scatterMax(
+      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterMax.Options... options) {
     return ScatterMax.create(scope, ref, indices, updates, options);
   }
 
@@ -4896,8 +4903,8 @@ public <T extends TNumber, U extends TNumber> ScatterMax<T> scatterMax(Operand<T
    * @param options carries optional attributes values
    * @return a new instance of ScatterMin
    */
-  public <T extends TNumber, U extends TNumber> ScatterMin<T> scatterMin(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterMin.Options... options) {
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMin<T> scatterMin(
+      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterMin.Options... options) {
     return ScatterMin.create(scope, ref, indices, updates, options);
   }
 
@@ -4930,7 +4937,7 @@ public <T extends TNumber, U extends TNumber> ScatterMin<T> scatterMin(Operand<T
    * @param options carries optional attributes values
    * @return a new instance of ScatterMul
    */
-  public <T extends TType, U extends TNumber> ScatterMul<T> scatterMul(Operand<T> ref,
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterMul<T> scatterMul(Operand<T> ref,
       Operand<U> indices, Operand<T> updates, ScatterMul.Options... options) {
     return ScatterMul.create(scope, ref, indices, updates, options);
   }
@@ -5021,7 +5028,7 @@ public <T extends TType, U extends TNumber> ScatterMul<T> scatterMul(Operand<T>
    * @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,
+  public <U extends Tensor, T extends Tensor & TNumber> ScatterNd<U> scatterNd(Operand<T> indices,
       Operand<U> updates, Operand<T> shape) {
     return ScatterNd.create(scope, indices, updates, shape);
   }
@@ -5068,7 +5075,7 @@ public <U extends TType, T extends TNumber> ScatterNd<U> scatterNd(Operand<T> in
    * @param options carries optional attributes values
    * @return a new instance of ScatterNdAdd
    */
-  public <T extends TType, U extends TNumber> ScatterNdAdd<T> scatterNdAdd(Operand<T> ref,
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdAdd<T> scatterNdAdd(Operand<T> ref,
       Operand<U> indices, Operand<T> updates, ScatterNdAdd.Options... options) {
     return ScatterNdAdd.create(scope, ref, indices, updates, options);
   }
@@ -5118,7 +5125,7 @@ public <T extends TType, U extends TNumber> ScatterNdAdd<T> scatterNdAdd(Operand
    *  to add to `input`.
    * @return a new instance of ScatterNdNonAliasingAdd
    */
-  public <T extends TType, U extends TNumber> ScatterNdNonAliasingAdd<T> scatterNdNonAliasingAdd(
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdNonAliasingAdd<T> scatterNdNonAliasingAdd(
       Operand<T> input, Operand<U> indices, Operand<T> updates) {
     return ScatterNdNonAliasingAdd.create(scope, input, indices, updates);
   }
@@ -5167,7 +5174,7 @@ public <T extends TType, U extends TNumber> ScatterNdNonAliasingAdd<T> scatterNd
    * @param options carries optional attributes values
    * @return a new instance of ScatterNdSub
    */
-  public <T extends TType, U extends TNumber> ScatterNdSub<T> scatterNdSub(Operand<T> ref,
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdSub<T> scatterNdSub(Operand<T> ref,
       Operand<U> indices, Operand<T> updates, ScatterNdSub.Options... options) {
     return ScatterNdSub.create(scope, ref, indices, updates, options);
   }
@@ -5218,8 +5225,8 @@ public <T extends TType, U extends TNumber> ScatterNdSub<T> scatterNdSub(Operand
    * @param options carries optional attributes values
    * @return a new instance of ScatterNdUpdate
    */
-  public <T extends TType, U extends TNumber> ScatterNdUpdate<T> scatterNdUpdate(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterNdUpdate.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdUpdate<T> scatterNdUpdate(
+      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterNdUpdate.Options... options) {
     return ScatterNdUpdate.create(scope, ref, indices, updates, options);
   }
 
@@ -5255,7 +5262,7 @@ public <T extends TType, U extends TNumber> ScatterNdUpdate<T> scatterNdUpdate(O
    * @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,
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterSub<T> scatterSub(Operand<T> ref,
       Operand<U> indices, Operand<T> updates, ScatterSub.Options... options) {
     return ScatterSub.create(scope, ref, indices, updates, options);
   }
@@ -5296,8 +5303,8 @@ public <T extends TType, U extends TNumber> ScatterSub<T> scatterSub(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ScatterUpdate
    */
-  public <T extends TType, U extends TNumber> ScatterUpdate<T> scatterUpdate(Operand<T> ref,
-      Operand<U> indices, Operand<T> updates, ScatterUpdate.Options... options) {
+  public <T extends Tensor, U extends Tensor & TNumber> ScatterUpdate<T> scatterUpdate(
+      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterUpdate.Options... options) {
     return ScatterUpdate.create(scope, ref, indices, updates, options);
   }
 
@@ -5309,7 +5316,7 @@ public <T extends TType, U extends TNumber> ScatterUpdate<T> scatterUpdate(Opera
    * @param e
    * @return a new instance of Select
    */
-  public <T extends TType> Select<T> select(Operand<TBool> condition, Operand<T> t, Operand<T> e) {
+  public <T extends Tensor> Select<T> select(Operand<TBool> condition, Operand<T> t, Operand<T> e) {
     return Select.create(scope, condition, t, e);
   }
 
@@ -5341,7 +5348,7 @@ public <T extends TType> Select<T> select(Operand<TBool> condition, Operand<T> t
    * @param y 1-D. Values to remove.
    * @return a new instance of SetDiff1d
    */
-  public <T extends TType> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T> y) {
+  public <T extends Tensor> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T> y) {
     return SetDiff1d.create(scope, x, y);
   }
 
@@ -5374,8 +5381,8 @@ public <T extends TType> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T>
    * @param outIdx
    * @return a new instance of SetDiff1d
    */
-  public <T extends TType, U extends TNumber> SetDiff1d<T, U> setDiff1d(Operand<T> x, Operand<T> y,
-      DataType<U> outIdx) {
+  public <T extends Tensor, U extends Tensor & TNumber> SetDiff1d<T, U> setDiff1d(Operand<T> x,
+      Operand<T> y, DataType<U> outIdx) {
     return SetDiff1d.create(scope, x, y, outIdx);
   }
 
@@ -5395,7 +5402,7 @@ public <T extends TType, U extends TNumber> SetDiff1d<T, U> setDiff1d(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of SetSize
    */
-  public <T extends TType> SetSize setSize(Operand<TInt64> setIndices, Operand<T> setValues,
+  public <T extends Tensor> SetSize setSize(Operand<TInt64> setIndices, Operand<T> setValues,
       Operand<TInt64> setShape, SetSize.Options... options) {
     return SetSize.create(scope, setIndices, setValues, setShape, options);
   }
@@ -5415,7 +5422,7 @@ public <T extends TType> SetSize setSize(Operand<TInt64> setIndices, Operand<T>
    * @param input
    * @return a new instance of Shape
    */
-  public <T extends TType> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T> input) {
+  public <T extends Tensor> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T> input) {
     return org.tensorflow.op.core.Shape.create(scope, input);
   }
 
@@ -5435,7 +5442,7 @@ public <T extends TType> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T> i
    * @param outType
    * @return a new instance of Shape
    */
-  public <U extends TNumber, T extends TType> org.tensorflow.op.core.Shape<U> shape(
+  public <U extends Tensor & TNumber, T extends Tensor> org.tensorflow.op.core.Shape<U> shape(
       Operand<T> input, DataType<U> outType) {
     return org.tensorflow.op.core.Shape.create(scope, input, outType);
   }
@@ -5449,7 +5456,7 @@ public <U extends TNumber, T extends TType> org.tensorflow.op.core.Shape<U> shap
    * @param input
    * @return a new instance of ShapeN
    */
-  public <T extends TType> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
+  public <T extends Tensor> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
     return ShapeN.create(scope, input);
   }
 
@@ -5463,7 +5470,7 @@ public <T extends TType> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
    * @param outType
    * @return a new instance of ShapeN
    */
-  public <U extends TNumber, T extends TType> ShapeN<U> shapeN(Iterable<Operand<T>> input,
+  public <U extends Tensor & TNumber, T extends Tensor> ShapeN<U> shapeN(Iterable<Operand<T>> input,
       DataType<U> outType) {
     return ShapeN.create(scope, input, outType);
   }
@@ -5484,7 +5491,7 @@ public <U extends TNumber, T extends TType> ShapeN<U> shapeN(Iterable<Operand<T>
    * @param input
    * @return a new instance of Size
    */
-  public <T extends TType> Size<TInt32> size(Operand<T> input) {
+  public <T extends Tensor> Size<TInt32> size(Operand<T> input) {
     return Size.create(scope, input);
   }
 
@@ -5505,7 +5512,8 @@ public <T extends TType> Size<TInt32> size(Operand<T> input) {
    * @param outType
    * @return a new instance of Size
    */
-  public <U extends TNumber, T extends TType> Size<U> size(Operand<T> input, DataType<U> outType) {
+  public <U extends Tensor & TNumber, T extends Tensor> Size<U> size(Operand<T> input,
+      DataType<U> outType) {
     return Size.create(scope, input, outType);
   }
 
@@ -5541,8 +5549,8 @@ public Skipgram skipgram(String filename, Long batchSize, Skipgram.Options... op
    *  size[i] = input.dim_size(i) - begin[i]).
    * @return a new instance of Slice
    */
-  public <T extends TType, U extends TNumber> Slice<T> slice(Operand<T> input, Operand<U> begin,
-      Operand<U> size) {
+  public <T extends Tensor, U extends Tensor & TNumber> Slice<T> slice(Operand<T> input,
+      Operand<U> begin, Operand<U> size) {
     return Slice.create(scope, input, begin, size);
   }
 
@@ -5553,7 +5561,7 @@ public <T extends TType, U extends TNumber> Slice<T> slice(Operand<T> input, Ope
    * @param input
    * @return a new instance of Snapshot
    */
-  public <T extends TType> Snapshot<T> snapshot(Operand<T> input) {
+  public <T extends Tensor> Snapshot<T> snapshot(Operand<T> input) {
     return Snapshot.create(scope, input);
   }
 
@@ -5667,7 +5675,7 @@ public <T extends TType> Snapshot<T> snapshot(Operand<T> input) {
    *  regular convolution.
    * @return a new instance of SpaceToBatchNd
    */
-  public <T extends TType, U extends TNumber, V extends TNumber> SpaceToBatchNd<T> spaceToBatchNd(
+  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> SpaceToBatchNd<T> spaceToBatchNd(
       Operand<T> input, Operand<U> blockShape, Operand<V> paddings) {
     return SpaceToBatchNd.create(scope, input, blockShape, paddings);
   }
@@ -5683,7 +5691,7 @@ public <T extends TType, U extends TNumber, V extends TNumber> SpaceToBatchNd<T>
    *  `value.shape[split_dim]`.
    * @return a new instance of Split
    */
-  public <T extends TType> Split<T> split(Operand<TInt32> axis, Operand<T> value, Long numSplit) {
+  public <T extends Tensor> Split<T> split(Operand<TInt32> axis, Operand<T> value, Long numSplit) {
     return Split.create(scope, axis, value, numSplit);
   }
 
@@ -5700,7 +5708,7 @@ public <T extends TType> Split<T> split(Operand<TInt32> axis, Operand<T> value,
    * @param numSplit
    * @return a new instance of SplitV
    */
-  public <T extends TType, U extends TNumber> SplitV<T> splitV(Operand<T> value,
+  public <T extends Tensor, U extends Tensor & TNumber> SplitV<T> splitV(Operand<T> value,
       Operand<U> sizeSplits, Operand<TInt32> axis, Long numSplit) {
     return SplitV.create(scope, value, sizeSplits, axis, numSplit);
   }
@@ -5729,7 +5737,7 @@ public <T extends TType, U extends TNumber> SplitV<T> splitV(Operand<T> value,
    * @param options carries optional attributes values
    * @return a new instance of Squeeze
    */
-  public <T extends TType> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options... options) {
+  public <T extends Tensor> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options... options) {
     return Squeeze.create(scope, input, options);
   }
 
@@ -5759,7 +5767,7 @@ public <T extends TType> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options...
    * @param options carries optional attributes values
    * @return a new instance of Stack
    */
-  public <T extends TType> Stack<T> stack(Iterable<Operand<T>> values, Stack.Options... options) {
+  public <T extends Tensor> Stack<T> stack(Iterable<Operand<T>> values, Stack.Options... options) {
     return Stack.create(scope, values, options);
   }
 
@@ -5849,7 +5857,7 @@ public StageSize stageSize(List<DataType<?>> dtypes, StageSize.Options... option
    * @param input
    * @return a new instance of StopGradient
    */
-  public <T extends TType> StopGradient<T> stopGradient(Operand<T> input) {
+  public <T extends Tensor> StopGradient<T> stopGradient(Operand<T> input) {
     return StopGradient.create(scope, input);
   }
 
@@ -5960,8 +5968,9 @@ public <T extends TType> StopGradient<T> stopGradient(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of StridedSlice
    */
-  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) {
+  public <T extends Tensor, U extends Tensor & 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);
   }
 
@@ -5984,7 +5993,7 @@ public <T extends TType, U extends TNumber> StridedSlice<T> stridedSlice(Operand
    * @param options carries optional attributes values
    * @return a new instance of StridedSliceAssign
    */
-  public <T extends TType, U extends TNumber> StridedSliceAssign<T> stridedSliceAssign(
+  public <T extends Tensor, U extends Tensor & 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);
@@ -6011,8 +6020,8 @@ public <T extends TType, U extends TNumber> StridedSliceAssign<T> stridedSliceAs
    * @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,
+  public <U extends Tensor, T extends Tensor & 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);
   }
@@ -6032,8 +6041,8 @@ public <U extends TType, T extends TNumber> StridedSliceGrad<U> stridedSliceGrad
    * @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) {
+  public <T extends Tensor, U extends Tensor & TNumber> Sum<T> sum(Operand<T> input,
+      Operand<U> axis, Sum.Options... options) {
     return Sum.create(scope, input, axis, options);
   }
 
@@ -6050,7 +6059,7 @@ public <T extends TType, U extends TNumber> Sum<T> sum(Operand<T> input, Operand
    * @param pred A scalar that specifies which output port will receive data.
    * @return a new instance of SwitchCond
    */
-  public <T extends TType> SwitchCond<T> switchCond(Operand<T> data, Operand<TBool> pred) {
+  public <T extends Tensor> SwitchCond<T> switchCond(Operand<T> data, Operand<TBool> pred) {
     return SwitchCond.create(scope, data, pred);
   }
 
@@ -6078,7 +6087,7 @@ public <T extends TType> SwitchCond<T> switchCond(Operand<T> data, Operand<TBool
    * @param options carries optional attributes values
    * @return a new instance of TemporaryVariable
    */
-  public <T extends TType> TemporaryVariable<T> temporaryVariable(Shape shape, DataType<T> dtype,
+  public <T extends Tensor> TemporaryVariable<T> temporaryVariable(Shape shape, DataType<T> dtype,
       TemporaryVariable.Options... options) {
     return TemporaryVariable.create(scope, shape, dtype, options);
   }
@@ -6093,7 +6102,7 @@ public <T extends TType> TemporaryVariable<T> temporaryVariable(Shape shape, Dat
    * @param options carries optional attributes values
    * @return a new instance of TensorArray
    */
-  public <T extends TType> TensorArray tensorArray(Operand<TInt32> size, DataType<T> dtype,
+  public <T extends Tensor> TensorArray tensorArray(Operand<TInt32> size, DataType<T> dtype,
       TensorArray.Options... options) {
     return TensorArray.create(scope, size, dtype, options);
   }
@@ -6132,7 +6141,7 @@ public TensorArrayClose tensorArrayClose(Operand<?> handle) {
    * @param options carries optional attributes values
    * @return a new instance of TensorArrayConcat
    */
-  public <T extends TType> TensorArrayConcat<T> tensorArrayConcat(Operand<?> handle,
+  public <T extends Tensor> TensorArrayConcat<T> tensorArrayConcat(Operand<?> handle,
       Operand<TFloat32> flowIn, DataType<T> dtype, TensorArrayConcat.Options... options) {
     return TensorArrayConcat.create(scope, handle, flowIn, dtype, options);
   }
@@ -6150,7 +6159,7 @@ public <T extends TType> TensorArrayConcat<T> tensorArrayConcat(Operand<?> handl
    * @param options carries optional attributes values
    * @return a new instance of TensorArrayGather
    */
-  public <T extends TType> TensorArrayGather<T> tensorArrayGather(Operand<?> handle,
+  public <T extends Tensor> 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);
@@ -6238,7 +6247,7 @@ public TensorArrayGradWithShape tensorArrayGradWithShape(Operand<?> handle,
    * @param options carries optional attributes values
    * @return a new instance of TensorArrayPack
    */
-  public <T extends TType> TensorArrayPack<T> tensorArrayPack(Operand<TString> handle,
+  public <T extends Tensor> TensorArrayPack<T> tensorArrayPack(Operand<TString> handle,
       Operand<TFloat32> flowIn, DataType<T> dtype, TensorArrayPack.Options... options) {
     return TensorArrayPack.create(scope, handle, flowIn, dtype, options);
   }
@@ -6253,7 +6262,7 @@ public <T extends TType> TensorArrayPack<T> tensorArrayPack(Operand<TString> han
    * @param dtype The type of the elem that is returned.
    * @return a new instance of TensorArrayRead
    */
-  public <T extends TType> TensorArrayRead<T> tensorArrayRead(Operand<?> handle,
+  public <T extends Tensor> TensorArrayRead<T> tensorArrayRead(Operand<?> handle,
       Operand<TInt32> index, Operand<TFloat32> flowIn, DataType<T> dtype) {
     return TensorArrayRead.create(scope, handle, index, flowIn, dtype);
   }
@@ -6269,7 +6278,7 @@ public <T extends TType> TensorArrayRead<T> tensorArrayRead(Operand<?> handle,
    * @param flowIn A float scalar that enforces proper chaining of operations.
    * @return a new instance of TensorArrayScatter
    */
-  public <T extends TType> TensorArrayScatter tensorArrayScatter(Operand<?> handle,
+  public <T extends Tensor> TensorArrayScatter tensorArrayScatter(Operand<?> handle,
       Operand<TInt32> indices, Operand<T> value, Operand<TFloat32> flowIn) {
     return TensorArrayScatter.create(scope, handle, indices, value, flowIn);
   }
@@ -6316,7 +6325,7 @@ public TensorArraySize tensorArraySize(Operand<?> handle, Operand<TFloat32> flow
    * @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,
+  public <T extends Tensor> TensorArraySplit tensorArraySplit(Operand<?> handle, Operand<T> value,
       Operand<TInt64> lengths, Operand<TFloat32> flowIn) {
     return TensorArraySplit.create(scope, handle, value, lengths, flowIn);
   }
@@ -6328,7 +6337,7 @@ public <T extends TType> TensorArraySplit tensorArraySplit(Operand<?> handle, Op
    * @param flowIn
    * @return a new instance of TensorArrayUnpack
    */
-  public <T extends TType> TensorArrayUnpack tensorArrayUnpack(Operand<TString> handle,
+  public <T extends Tensor> TensorArrayUnpack tensorArrayUnpack(Operand<TString> handle,
       Operand<T> value, Operand<TFloat32> flowIn) {
     return TensorArrayUnpack.create(scope, handle, value, flowIn);
   }
@@ -6342,7 +6351,7 @@ public <T extends TType> TensorArrayUnpack tensorArrayUnpack(Operand<TString> ha
    * @param flowIn A float scalar that enforces proper chaining of operations.
    * @return a new instance of TensorArrayWrite
    */
-  public <T extends TType> TensorArrayWrite tensorArrayWrite(Operand<?> handle,
+  public <T extends Tensor> TensorArrayWrite tensorArrayWrite(Operand<?> handle,
       Operand<TInt32> index, Operand<T> value, Operand<TFloat32> flowIn) {
     return TensorArrayWrite.create(scope, handle, index, value, flowIn);
   }
@@ -6369,7 +6378,7 @@ public <T extends TType> TensorArrayWrite tensorArrayWrite(Operand<?> handle,
    * @param elementDtype
    * @return a new instance of TensorListConcat
    */
-  public <U extends TType, T extends TNumber> TensorListConcat<U> tensorListConcat(
+  public <U extends Tensor, T extends Tensor & TNumber> TensorListConcat<U> tensorListConcat(
       Operand<?> inputHandle, Operand<T> elementShape, Operand<TInt64> leadingDims,
       DataType<U> elementDtype) {
     return TensorListConcat.create(scope, inputHandle, elementShape, leadingDims, elementDtype);
@@ -6382,7 +6391,7 @@ public <U extends TType, T extends TNumber> TensorListConcat<U> tensorListConcat
    * @param elementDtype
    * @return a new instance of TensorListConcatLists
    */
-  public <T extends TType> TensorListConcatLists tensorListConcatLists(Operand<?> inputA,
+  public <T extends Tensor> TensorListConcatLists tensorListConcatLists(Operand<?> inputA,
       Operand<?> inputB, DataType<T> elementDtype) {
     return TensorListConcatLists.create(scope, inputA, inputB, elementDtype);
   }
@@ -6398,7 +6407,7 @@ public <T extends TType> TensorListConcatLists tensorListConcatLists(Operand<?>
    * @param shapeType
    * @return a new instance of TensorListElementShape
    */
-  public <T extends TNumber> TensorListElementShape<T> tensorListElementShape(
+  public <T extends Tensor & TNumber> TensorListElementShape<T> tensorListElementShape(
       Operand<?> inputHandle, DataType<T> shapeType) {
     return TensorListElementShape.create(scope, inputHandle, shapeType);
   }
@@ -6415,7 +6424,7 @@ public <T extends TNumber> TensorListElementShape<T> tensorListElementShape(
    * @param elementShape
    * @return a new instance of TensorListFromTensor
    */
-  public <T extends TType, U extends TNumber> TensorListFromTensor tensorListFromTensor(
+  public <T extends Tensor, U extends Tensor & TNumber> TensorListFromTensor tensorListFromTensor(
       Operand<T> tensor, Operand<U> elementShape) {
     return TensorListFromTensor.create(scope, tensor, elementShape);
   }
@@ -6437,7 +6446,7 @@ public <T extends TType, U extends TNumber> TensorListFromTensor tensorListFromT
    * @param elementDtype
    * @return a new instance of TensorListGather
    */
-  public <T extends TType> TensorListGather<T> tensorListGather(Operand<?> inputHandle,
+  public <T extends Tensor> TensorListGather<T> tensorListGather(Operand<?> inputHandle,
       Operand<TInt32> indices, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     return TensorListGather.create(scope, inputHandle, indices, elementShape, elementDtype);
   }
@@ -6451,7 +6460,7 @@ public <T extends TType> TensorListGather<T> tensorListGather(Operand<?> inputHa
    * @param elementDtype
    * @return a new instance of TensorListGetItem
    */
-  public <T extends TType> TensorListGetItem<T> tensorListGetItem(Operand<?> inputHandle,
+  public <T extends Tensor> TensorListGetItem<T> tensorListGetItem(Operand<?> inputHandle,
       Operand<TInt32> index, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     return TensorListGetItem.create(scope, inputHandle, index, elementShape, elementDtype);
   }
@@ -6485,7 +6494,7 @@ public TensorListLength tensorListLength(Operand<?> inputHandle) {
    * @param elementDtype
    * @return a new instance of TensorListPopBack
    */
-  public <T extends TType> TensorListPopBack<T> tensorListPopBack(Operand<?> inputHandle,
+  public <T extends Tensor> TensorListPopBack<T> tensorListPopBack(Operand<?> inputHandle,
       Operand<TInt32> elementShape, DataType<T> elementDtype) {
     return TensorListPopBack.create(scope, inputHandle, elementShape, elementDtype);
   }
@@ -6503,7 +6512,7 @@ public <T extends TType> TensorListPopBack<T> tensorListPopBack(Operand<?> input
    * @param tensor
    * @return a new instance of TensorListPushBack
    */
-  public <T extends TType> TensorListPushBack tensorListPushBack(Operand<?> inputHandle,
+  public <T extends Tensor> TensorListPushBack tensorListPushBack(Operand<?> inputHandle,
       Operand<T> tensor) {
     return TensorListPushBack.create(scope, inputHandle, tensor);
   }
@@ -6514,7 +6523,7 @@ public <T extends TType> TensorListPushBack tensorListPushBack(Operand<?> inputH
    * @param tensor
    * @return a new instance of TensorListPushBackBatch
    */
-  public <T extends TType> TensorListPushBackBatch tensorListPushBackBatch(Operand<?> inputHandles,
+  public <T extends Tensor> TensorListPushBackBatch tensorListPushBackBatch(Operand<?> inputHandles,
       Operand<T> tensor) {
     return TensorListPushBackBatch.create(scope, inputHandles, tensor);
   }
@@ -6532,7 +6541,7 @@ public <T extends TType> TensorListPushBackBatch tensorListPushBackBatch(Operand
    * @param elementDtype
    * @return a new instance of TensorListReserve
    */
-  public <T extends TNumber, U extends TType> TensorListReserve tensorListReserve(
+  public <T extends Tensor & TNumber, U extends Tensor> TensorListReserve tensorListReserve(
       Operand<T> elementShape, Operand<TInt32> numElements, DataType<U> elementDtype) {
     return TensorListReserve.create(scope, elementShape, numElements, elementDtype);
   }
@@ -6573,8 +6582,9 @@ public TensorListResize tensorListResize(Operand<?> inputHandle, Operand<TInt32>
    * @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) {
+  public <T extends Tensor, U extends Tensor & TNumber> TensorListScatter tensorListScatter(
+      Operand<T> tensor, Operand<TInt32> indices, Operand<U> elementShape,
+      Operand<TInt32> numElements) {
     return TensorListScatter.create(scope, tensor, indices, elementShape, numElements);
   }
 
@@ -6594,7 +6604,7 @@ public <T extends TType, U extends TNumber> TensorListScatter tensorListScatter(
    * @param indices
    * @return a new instance of TensorListScatterIntoExistingList
    */
-  public <T extends TType> TensorListScatterIntoExistingList tensorListScatterIntoExistingList(
+  public <T extends Tensor> TensorListScatterIntoExistingList tensorListScatterIntoExistingList(
       Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
     return TensorListScatterIntoExistingList.create(scope, inputHandle, tensor, indices);
   }
@@ -6606,7 +6616,7 @@ public <T extends TType> TensorListScatterIntoExistingList tensorListScatterInto
    * @param item
    * @return a new instance of TensorListSetItem
    */
-  public <T extends TType> TensorListSetItem tensorListSetItem(Operand<?> inputHandle,
+  public <T extends Tensor> TensorListSetItem tensorListSetItem(Operand<?> inputHandle,
       Operand<TInt32> index, Operand<T> item) {
     return TensorListSetItem.create(scope, inputHandle, index, item);
   }
@@ -6627,8 +6637,8 @@ public <T extends TType> TensorListSetItem tensorListSetItem(Operand<?> inputHan
    * @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) {
+  public <T extends Tensor, U extends Tensor & TNumber> TensorListSplit tensorListSplit(
+      Operand<T> tensor, Operand<U> elementShape, Operand<TInt64> lengths) {
     return TensorListSplit.create(scope, tensor, elementShape, lengths);
   }
 
@@ -6648,7 +6658,7 @@ public <T extends TType, U extends TNumber> TensorListSplit tensorListSplit(Oper
    * @param options carries optional attributes values
    * @return a new instance of TensorListStack
    */
-  public <T extends TType> TensorListStack<T> tensorListStack(Operand<?> inputHandle,
+  public <T extends Tensor> TensorListStack<T> tensorListStack(Operand<?> inputHandle,
       Operand<TInt32> elementShape, DataType<T> elementDtype, TensorListStack.Options... options) {
     return TensorListStack.create(scope, inputHandle, elementShape, elementDtype, options);
   }
@@ -6721,7 +6731,7 @@ public <T extends TType> TensorListStack<T> tensorListStack(Operand<?> inputHand
    * @param updates Updates to scatter into output.
    * @return a new instance of TensorScatterNdAdd
    */
-  public <T extends TType, U extends TNumber> TensorScatterNdAdd<T> tensorScatterNdAdd(
+  public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdAdd<T> tensorScatterNdAdd(
       Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     return TensorScatterNdAdd.create(scope, tensor, indices, updates);
   }
@@ -6794,7 +6804,7 @@ public <T extends TType, U extends TNumber> TensorScatterNdAdd<T> tensorScatterN
    * @param updates Updates to scatter into output.
    * @return a new instance of TensorScatterNdSub
    */
-  public <T extends TType, U extends TNumber> TensorScatterNdSub<T> tensorScatterNdSub(
+  public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdSub<T> tensorScatterNdSub(
       Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     return TensorScatterNdSub.create(scope, tensor, indices, updates);
   }
@@ -6882,7 +6892,7 @@ public <T extends TType, U extends TNumber> TensorScatterNdSub<T> tensorScatterN
    * @param updates Updates to scatter into output.
    * @return a new instance of TensorScatterNdUpdate
    */
-  public <T extends TType, U extends TNumber> TensorScatterNdUpdate<T> tensorScatterNdUpdate(
+  public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdUpdate<T> tensorScatterNdUpdate(
       Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     return TensorScatterNdUpdate.create(scope, tensor, indices, updates);
   }
@@ -6906,7 +6916,7 @@ public <T extends TType, U extends TNumber> TensorScatterNdUpdate<T> tensorScatt
    * @param options carries optional attributes values
    * @return a new instance of TensorStridedSliceUpdate
    */
-  public <T extends TType, U extends TNumber> TensorStridedSliceUpdate<T> tensorStridedSliceUpdate(
+  public <T extends Tensor, U extends Tensor & 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);
@@ -6947,7 +6957,8 @@ public <T extends TType, U extends TNumber> TensorStridedSliceUpdate<T> tensorSt
    * @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) {
+  public <T extends Tensor, U extends Tensor & TNumber> Tile<T> tile(Operand<T> input,
+      Operand<U> multiples) {
     return Tile.create(scope, input, multiples);
   }
 
@@ -7061,7 +7072,7 @@ public TryRpc tryRpc(Operand<TString> address, Operand<TString> method, Operand<
    * @param options carries optional attributes values
    * @return a new instance of Unbatch
    */
-  public <T extends TType> Unbatch<T> unbatch(Operand<T> batchedTensor, Operand<TInt64> batchIndex,
+  public <T extends Tensor> 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);
   }
@@ -7092,7 +7103,7 @@ public <T extends TType> Unbatch<T> unbatch(Operand<T> batchedTensor, Operand<TI
    * @param options carries optional attributes values
    * @return a new instance of UnbatchGrad
    */
-  public <T extends TType> UnbatchGrad<T> unbatchGrad(Operand<T> originalInput,
+  public <T extends Tensor> 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);
@@ -7147,7 +7158,7 @@ public <T extends TType> UnbatchGrad<T> unbatchGrad(Operand<T> originalInput,
    *  find the unique elements.
    * @return a new instance of Unique
    */
-  public <T extends TType, U extends TNumber> Unique<T, TInt32> unique(Operand<T> x,
+  public <T extends Tensor, U extends Tensor & TNumber> Unique<T, TInt32> unique(Operand<T> x,
       Operand<U> axis) {
     return Unique.create(scope, x, axis);
   }
@@ -7202,8 +7213,8 @@ public <T extends TType, U extends TNumber> Unique<T, TInt32> unique(Operand<T>
    * @param outIdx
    * @return a new instance of Unique
    */
-  public <T extends TType, V extends TNumber, U extends TNumber> Unique<T, V> unique(Operand<T> x,
-      Operand<U> axis, DataType<V> outIdx) {
+  public <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> Unique<T, V> unique(
+      Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
     return Unique.create(scope, x, axis, outIdx);
   }
 
@@ -7260,7 +7271,7 @@ public <T extends TType, V extends TNumber, U extends TNumber> Unique<T, V> uniq
    *  find the unique elements.
    * @return a new instance of UniqueWithCounts
    */
-  public <T extends TType, U extends TNumber> UniqueWithCounts<T, TInt32> uniqueWithCounts(
+  public <T extends Tensor, U extends Tensor & TNumber> UniqueWithCounts<T, TInt32> uniqueWithCounts(
       Operand<T> x, Operand<U> axis) {
     return UniqueWithCounts.create(scope, x, axis);
   }
@@ -7319,7 +7330,7 @@ public <T extends TType, U extends TNumber> UniqueWithCounts<T, TInt32> uniqueWi
    * @param outIdx
    * @return a new instance of UniqueWithCounts
    */
-  public <T extends TType, V extends TNumber, U extends TNumber> UniqueWithCounts<T, V> uniqueWithCounts(
+  public <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> UniqueWithCounts<T, V> uniqueWithCounts(
       Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
     return UniqueWithCounts.create(scope, x, axis, outIdx);
   }
@@ -7352,7 +7363,8 @@ public <T extends TType, V extends TNumber, U extends TNumber> UniqueWithCounts<
    *  indices.
    * @return a new instance of UnravelIndex
    */
-  public <T extends TNumber> UnravelIndex<T> unravelIndex(Operand<T> indices, Operand<T> dims) {
+  public <T extends Tensor & TNumber> UnravelIndex<T> unravelIndex(Operand<T> indices,
+      Operand<T> dims) {
     return UnravelIndex.create(scope, indices, dims);
   }
 
@@ -7378,7 +7390,7 @@ public <T extends TNumber> UnravelIndex<T> unravelIndex(Operand<T> indices, Oper
    * @param options carries optional attributes values
    * @return a new instance of Unstack
    */
-  public <T extends TType> Unstack<T> unstack(Operand<T> value, Long num,
+  public <T extends Tensor> Unstack<T> unstack(Operand<T> value, Long num,
       Unstack.Options... options) {
     return Unstack.create(scope, value, num, options);
   }
@@ -7406,7 +7418,7 @@ public Unstage unstage(List<DataType<?>> dtypes, Unstage.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of VarHandleOp
    */
-  public <T extends TType> VarHandleOp varHandleOp(DataType<T> dtype, Shape shape,
+  public <T extends Tensor> VarHandleOp varHandleOp(DataType<T> dtype, Shape shape,
       VarHandleOp.Options... options) {
     return VarHandleOp.create(scope, dtype, shape, options);
   }
@@ -7432,7 +7444,7 @@ public VarIsInitializedOp varIsInitializedOp(Operand<?> resource) {
    * @param options carries optional attributes values
    * @return a new instance of Variable
    */
-  public <T extends TType> Variable<T> variable(Operand<T> init, Variable.Options... options) {
+  public <T extends Tensor> Variable<T> variable(Operand<T> init, Variable.Options... options) {
     return Helpers.createVariableWithInit(scope, init, options);
   }
 
@@ -7449,7 +7461,7 @@ public <T extends TType> Variable<T> variable(Operand<T> init, Variable.Options.
    * @param options carries optional attributes values
    * @return a new instance of Variable
    */
-  public <T extends TType> Variable<T> variable(Shape shape, DataType<T> dtype,
+  public <T extends Tensor> Variable<T> variable(Shape shape, DataType<T> dtype,
       Variable.Options... options) {
     return Variable.create(scope, shape, dtype, options);
   }
@@ -7489,7 +7501,8 @@ public VariableShape<TInt32> variableShape(Operand<?> input) {
    * @param outType
    * @return a new instance of VariableShape
    */
-  public <T extends TNumber> VariableShape<T> variableShape(Operand<?> input, DataType<T> outType) {
+  public <T extends Tensor & TNumber> VariableShape<T> variableShape(Operand<?> input,
+      DataType<T> outType) {
     return VariableShape.create(scope, input, outType);
   }
 
@@ -7558,7 +7571,7 @@ public <T extends TNumber> VariableShape<T> variableShape(Operand<?> input, Data
    * @param condition
    * @return a new instance of Where
    */
-  public <T extends TType> Where where(Operand<T> condition) {
+  public <T extends Tensor> Where where(Operand<T> condition) {
     return Where.create(scope, condition);
   }
 
@@ -7571,7 +7584,8 @@ public <T extends TType> Where where(Operand<T> condition) {
    * @return a constant tensor initialized with zeros
    * @throws IllegalArgumentException if the tensor type or shape cannot be initialized with zeros.
    */
-  public <T extends TType, U extends TNumber> Zeros<T> zeros(Operand<U> dims, DataType<T> type) {
+  public <T extends Tensor, U extends Tensor & TNumber> Zeros<T> zeros(Operand<U> dims,
+      DataType<T> type) {
     return Zeros.create(scope, dims, type);
   }
 
@@ -7582,7 +7596,7 @@ public <T extends TType, U extends TNumber> Zeros<T> zeros(Operand<U> dims, Data
    * @param x a tensor of type T.
    * @return a new instance of ZerosLike
    */
-  public <T extends TType> ZerosLike<T> zerosLike(Operand<T> x) {
+  public <T extends Tensor> ZerosLike<T> zerosLike(Operand<T> x) {
     return ZerosLike.create(scope, x);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java
index 7a78cd2f011..7f5dc4e8271 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java
@@ -19,6 +19,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.quantization.Dequantize;
 import org.tensorflow.op.quantization.FakeQuantWithMinMaxArgs;
 import org.tensorflow.op.quantization.FakeQuantWithMinMaxArgsGradient;
@@ -35,7 +36,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code quantization} operations as {@link Op Op}s
@@ -107,7 +107,7 @@ public final class QuantizationOps {
    * @param options carries optional attributes values
    * @return a new instance of Dequantize
    */
-  public <T extends TType> Dequantize<TFloat32> dequantize(Operand<T> input,
+  public <T extends Tensor> Dequantize<TFloat32> dequantize(Operand<T> input,
       Operand<TFloat32> minRange, Operand<TFloat32> maxRange, Dequantize.Options... options) {
     return Dequantize.create(scope, input, minRange, maxRange, options);
   }
@@ -172,7 +172,7 @@ public <T extends TType> Dequantize<TFloat32> dequantize(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of Dequantize
    */
-  public <U extends TNumber, T extends TType> Dequantize<U> dequantize(Operand<T> input,
+  public <U extends Tensor & TNumber, T extends Tensor> Dequantize<U> dequantize(Operand<T> input,
       Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<U> dtype,
       Dequantize.Options... options) {
     return Dequantize.create(scope, input, minRange, maxRange, dtype, options);
@@ -453,8 +453,9 @@ public FakeQuantWithMinMaxVarsPerChannelGradient fakeQuantWithMinMaxVarsPerChann
    * @param options carries optional attributes values
    * @return a new instance of Quantize
    */
-  public <T extends TType> Quantize<T> quantize(Operand<TFloat32> input, Operand<TFloat32> minRange,
-      Operand<TFloat32> maxRange, DataType<T> T, Quantize.Options... options) {
+  public <T extends Tensor> Quantize<T> quantize(Operand<TFloat32> input,
+      Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<T> T,
+      Quantize.Options... options) {
     return Quantize.create(scope, input, minRange, maxRange, T, options);
   }
 
@@ -472,8 +473,8 @@ public <T extends TType> Quantize<T> quantize(Operand<TFloat32> input, Operand<T
    * @param options carries optional attributes values
    * @return a new instance of QuantizeAndDequantize
    */
-  public <T extends TNumber> QuantizeAndDequantize<T> quantizeAndDequantize(Operand<T> input,
-      Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits,
+  public <T extends Tensor & TNumber> QuantizeAndDequantize<T> quantizeAndDequantize(
+      Operand<T> input, Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits,
       QuantizeAndDequantize.Options... options) {
     return QuantizeAndDequantize.create(scope, input, inputMin, inputMax, numBits, options);
   }
@@ -511,7 +512,7 @@ public <T extends TNumber> QuantizeAndDequantize<T> quantizeAndDequantize(Operan
    * @param outType The type of the output. Should be a lower bit depth than Tinput.
    * @return a new instance of QuantizeDownAndShrinkRange
    */
-  public <U extends TType, T extends TType> QuantizeDownAndShrinkRange<U> quantizeDownAndShrinkRange(
+  public <U extends Tensor, T extends Tensor> QuantizeDownAndShrinkRange<U> quantizeDownAndShrinkRange(
       Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax,
       DataType<U> outType) {
     return QuantizeDownAndShrinkRange.create(scope, input, inputMin, inputMax, outType);
@@ -529,7 +530,7 @@ public <U extends TType, T extends TType> QuantizeDownAndShrinkRange<U> quantize
    * @param inputMaxes The maximum scalar values for each of the input tensors.
    * @return a new instance of QuantizedConcat
    */
-  public <T extends TType> QuantizedConcat<T> quantizedConcat(Operand<TInt32> concatDim,
+  public <T extends Tensor> QuantizedConcat<T> quantizedConcat(Operand<TInt32> concatDim,
       Iterable<Operand<T>> values, Iterable<Operand<TFloat32>> inputMins,
       Iterable<Operand<TFloat32>> inputMaxes) {
     return QuantizedConcat.create(scope, concatDim, values, inputMins, inputMaxes);
@@ -548,7 +549,7 @@ public <T extends TType> QuantizedConcat<T> quantizedConcat(Operand<TInt32> conc
    * @param inputMax The float value that the maximum quantized input value represents.
    * @return a new instance of RequantizationRange
    */
-  public <T extends TType> RequantizationRange requantizationRange(Operand<T> input,
+  public <T extends Tensor> RequantizationRange requantizationRange(Operand<T> input,
       Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
     return RequantizationRange.create(scope, input, inputMin, inputMax);
   }
@@ -573,7 +574,7 @@ public <T extends TType> RequantizationRange requantizationRange(Operand<T> inpu
    * @param outType The type of the output. Should be a lower bit depth than Tinput.
    * @return a new instance of Requantize
    */
-  public <U extends TType, T extends TType> Requantize<U> requantize(Operand<T> input,
+  public <U extends Tensor, T extends Tensor> Requantize<U> requantize(Operand<T> input,
       Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin,
       Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
     return Requantize.create(scope, input, inputMin, inputMax, requestedOutputMin, requestedOutputMax, outType);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java
index 071e77c7a70..cb9410ebb2a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java
@@ -19,6 +19,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.random.AllCandidateSampler;
 import org.tensorflow.op.random.LogUniformCandidateSampler;
 import org.tensorflow.op.random.Multinomial;
@@ -42,7 +43,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code random} operations as {@link Op Op}s
@@ -124,7 +124,7 @@ public LogUniformCandidateSampler logUniformCandidateSampler(Operand<TInt64> tru
    * @param options carries optional attributes values
    * @return a new instance of Multinomial
    */
-  public <T extends TNumber> Multinomial<TInt64> multinomial(Operand<T> logits,
+  public <T extends Tensor & TNumber> Multinomial<TInt64> multinomial(Operand<T> logits,
       Operand<TInt32> numSamples, Multinomial.Options... options) {
     return Multinomial.create(scope, logits, numSamples, options);
   }
@@ -140,8 +140,9 @@ public <T extends TNumber> Multinomial<TInt64> multinomial(Operand<T> logits,
    * @param options carries optional attributes values
    * @return a new instance of Multinomial
    */
-  public <U extends TNumber, T extends TNumber> Multinomial<U> multinomial(Operand<T> logits,
-      Operand<TInt32> numSamples, DataType<U> outputDtype, Multinomial.Options... options) {
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> Multinomial<U> multinomial(
+      Operand<T> logits, Operand<TInt32> numSamples, DataType<U> outputDtype,
+      Multinomial.Options... options) {
     return Multinomial.create(scope, logits, numSamples, outputDtype, options);
   }
 
@@ -161,7 +162,7 @@ public <U extends TNumber, T extends TNumber> Multinomial<U> multinomial(Operand
    * @param options carries optional attributes values
    * @return a new instance of ParameterizedTruncatedNormal
    */
-  public <U extends TNumber, T extends TNumber> ParameterizedTruncatedNormal<U> parameterizedTruncatedNormal(
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> ParameterizedTruncatedNormal<U> parameterizedTruncatedNormal(
       Operand<T> shape, Operand<U> means, Operand<U> stdevs, Operand<U> minvals, Operand<U> maxvals,
       ParameterizedTruncatedNormal.Options... options) {
     return ParameterizedTruncatedNormal.create(scope, shape, means, stdevs, minvals, maxvals, options);
@@ -182,8 +183,8 @@ public <U extends TNumber, T extends TNumber> ParameterizedTruncatedNormal<U> pa
    * @param options carries optional attributes values
    * @return a new instance of RandomGamma
    */
-  public <U extends TNumber, T extends TNumber> RandomGamma<U> randomGamma(Operand<T> shape,
-      Operand<U> alpha, RandomGamma.Options... options) {
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomGamma<U> randomGamma(
+      Operand<T> shape, Operand<U> alpha, RandomGamma.Options... options) {
     return RandomGamma.create(scope, shape, alpha, options);
   }
 
@@ -208,7 +209,7 @@ public <U extends TNumber, T extends TNumber> RandomGamma<U> randomGamma(Operand
    * @param options carries optional attributes values
    * @return a new instance of RandomPoisson
    */
-  public <T extends TNumber, U extends TNumber> RandomPoisson<TInt64> randomPoisson(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<TInt64> randomPoisson(
       Operand<T> shape, Operand<U> rate, RandomPoisson.Options... options) {
     return RandomPoisson.create(scope, shape, rate, options);
   }
@@ -235,7 +236,7 @@ public <T extends TNumber, U extends TNumber> RandomPoisson<TInt64> randomPoisso
    * @param options carries optional attributes values
    * @return a new instance of RandomPoisson
    */
-  public <V extends TNumber, T extends TNumber, U extends TNumber> RandomPoisson<V> randomPoisson(
+  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<V> randomPoisson(
       Operand<T> shape, Operand<U> rate, DataType<V> dtype, RandomPoisson.Options... options) {
     return RandomPoisson.create(scope, shape, rate, dtype, options);
   }
@@ -257,7 +258,7 @@ public <V extends TNumber, T extends TNumber, U extends TNumber> RandomPoisson<V
    * @param options carries optional attributes values
    * @return a new instance of RandomShuffle
    */
-  public <T extends TType> RandomShuffle<T> randomShuffle(Operand<T> value,
+  public <T extends Tensor> RandomShuffle<T> randomShuffle(Operand<T> value,
       RandomShuffle.Options... options) {
     return RandomShuffle.create(scope, value, options);
   }
@@ -273,7 +274,7 @@ public <T extends TType> RandomShuffle<T> randomShuffle(Operand<T> value,
    * @param options carries optional attributes values
    * @return a new instance of RandomStandardNormal
    */
-  public <U extends TNumber, T extends TNumber> RandomStandardNormal<U> randomStandardNormal(
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomStandardNormal<U> randomStandardNormal(
       Operand<T> shape, DataType<U> dtype, RandomStandardNormal.Options... options) {
     return RandomStandardNormal.create(scope, shape, dtype, options);
   }
@@ -290,8 +291,8 @@ public <U extends TNumber, T extends TNumber> RandomStandardNormal<U> randomStan
    * @param options carries optional attributes values
    * @return a new instance of RandomUniform
    */
-  public <U extends TNumber, T extends TNumber> RandomUniform<U> randomUniform(Operand<T> shape,
-      DataType<U> dtype, RandomUniform.Options... options) {
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniform<U> randomUniform(
+      Operand<T> shape, DataType<U> dtype, RandomUniform.Options... options) {
     return RandomUniform.create(scope, shape, dtype, options);
   }
 
@@ -313,7 +314,7 @@ public <U extends TNumber, T extends TNumber> RandomUniform<U> randomUniform(Ope
    * @param options carries optional attributes values
    * @return a new instance of RandomUniformInt
    */
-  public <U extends TNumber, T extends TNumber> RandomUniformInt<U> randomUniformInt(
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniformInt<U> randomUniformInt(
       Operand<T> shape, Operand<U> minval, Operand<U> maxval, RandomUniformInt.Options... options) {
     return RandomUniformInt.create(scope, shape, minval, maxval, options);
   }
@@ -339,7 +340,7 @@ public RecordInput recordInput(String filePattern, RecordInput.Options... option
    * @param probs
    * @return a new instance of StatefulRandomBinomial
    */
-  public <T extends TNumber, U extends TNumber> StatefulRandomBinomial<TInt64> statefulRandomBinomial(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<TInt64> statefulRandomBinomial(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts,
       Operand<U> probs) {
     return StatefulRandomBinomial.create(scope, resource, algorithm, shape, counts, probs);
@@ -356,7 +357,7 @@ public <T extends TNumber, U extends TNumber> StatefulRandomBinomial<TInt64> sta
    * @param dtype
    * @return a new instance of StatefulRandomBinomial
    */
-  public <V extends TNumber, T extends TNumber, U extends TNumber> StatefulRandomBinomial<V> statefulRandomBinomial(
+  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<V> statefulRandomBinomial(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts,
       Operand<U> probs, DataType<V> dtype) {
     return StatefulRandomBinomial.create(scope, resource, algorithm, shape, counts, probs, dtype);
@@ -373,7 +374,7 @@ public <V extends TNumber, T extends TNumber, U extends TNumber> StatefulRandomB
    * @param shape The shape of the output tensor.
    * @return a new instance of StatefulStandardNormal
    */
-  public <T extends TType> StatefulStandardNormal<TFloat32> statefulStandardNormal(
+  public <T extends Tensor> StatefulStandardNormal<TFloat32> statefulStandardNormal(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return StatefulStandardNormal.create(scope, resource, algorithm, shape);
   }
@@ -390,7 +391,7 @@ public <T extends TType> StatefulStandardNormal<TFloat32> statefulStandardNormal
    * @param dtype The type of the output.
    * @return a new instance of StatefulStandardNormal
    */
-  public <U extends TType, T extends TType> StatefulStandardNormal<U> statefulStandardNormal(
+  public <U extends Tensor, T extends Tensor> StatefulStandardNormal<U> statefulStandardNormal(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     return StatefulStandardNormal.create(scope, resource, algorithm, shape, dtype);
   }
@@ -405,7 +406,7 @@ public <U extends TType, T extends TType> StatefulStandardNormal<U> statefulStan
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessMultinomial
    */
-  public <T extends TNumber, U extends TNumber> StatelessMultinomial<TInt64> statelessMultinomial(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<TInt64> statelessMultinomial(
       Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed) {
     return StatelessMultinomial.create(scope, logits, numSamples, seed);
   }
@@ -421,7 +422,7 @@ public <T extends TNumber, U extends TNumber> StatelessMultinomial<TInt64> state
    * @param outputDtype
    * @return a new instance of StatelessMultinomial
    */
-  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessMultinomial<V> statelessMultinomial(
+  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<V> statelessMultinomial(
       Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed, DataType<V> outputDtype) {
     return StatelessMultinomial.create(scope, logits, numSamples, seed, outputDtype);
   }
@@ -438,7 +439,7 @@ public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessMultin
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessRandomNormal
    */
-  public <T extends TNumber, U extends TNumber> StatelessRandomNormal<TFloat32> statelessRandomNormal(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<TFloat32> statelessRandomNormal(
       Operand<T> shape, Operand<U> seed) {
     return StatelessRandomNormal.create(scope, shape, seed);
   }
@@ -456,7 +457,7 @@ public <T extends TNumber, U extends TNumber> StatelessRandomNormal<TFloat32> st
    * @param dtype The type of the output.
    * @return a new instance of StatelessRandomNormal
    */
-  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomNormal<V> statelessRandomNormal(
+  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<V> statelessRandomNormal(
       Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     return StatelessRandomNormal.create(scope, shape, seed, dtype);
   }
@@ -474,7 +475,7 @@ public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandom
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessRandomUniform
    */
-  public <T extends TNumber, U extends TNumber> StatelessRandomUniform<TFloat32> statelessRandomUniform(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<TFloat32> statelessRandomUniform(
       Operand<T> shape, Operand<U> seed) {
     return StatelessRandomUniform.create(scope, shape, seed);
   }
@@ -493,7 +494,7 @@ public <T extends TNumber, U extends TNumber> StatelessRandomUniform<TFloat32> s
    * @param dtype The type of the output.
    * @return a new instance of StatelessRandomUniform
    */
-  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniform<V> statelessRandomUniform(
+  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<V> statelessRandomUniform(
       Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     return StatelessRandomUniform.create(scope, shape, seed, dtype);
   }
@@ -512,7 +513,7 @@ public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandom
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessTruncatedNormal
    */
-  public <T extends TNumber, U extends TNumber> StatelessTruncatedNormal<TFloat32> statelessTruncatedNormal(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<TFloat32> statelessTruncatedNormal(
       Operand<T> shape, Operand<U> seed) {
     return StatelessTruncatedNormal.create(scope, shape, seed);
   }
@@ -532,7 +533,7 @@ public <T extends TNumber, U extends TNumber> StatelessTruncatedNormal<TFloat32>
    * @param dtype The type of the output.
    * @return a new instance of StatelessTruncatedNormal
    */
-  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessTruncatedNormal<V> statelessTruncatedNormal(
+  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<V> statelessTruncatedNormal(
       Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     return StatelessTruncatedNormal.create(scope, shape, seed, dtype);
   }
@@ -550,8 +551,8 @@ public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessTrunca
    * @param options carries optional attributes values
    * @return a new instance of TruncatedNormal
    */
-  public <U extends TNumber, T extends TNumber> TruncatedNormal<U> truncatedNormal(Operand<T> shape,
-      DataType<U> dtype, TruncatedNormal.Options... options) {
+  public <U extends Tensor & TNumber, T extends Tensor & TNumber> TruncatedNormal<U> truncatedNormal(
+      Operand<T> shape, DataType<U> dtype, TruncatedNormal.Options... options) {
     return TruncatedNormal.create(scope, shape, dtype, options);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java
index 81c692571f1..077dd664c61 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java
@@ -19,12 +19,12 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.core.Shape;
 import org.tensorflow.op.core.Shapes;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code shape} operations as {@link Op Op}s
@@ -78,7 +78,8 @@ public Operand<TInt32> append(Shape<TInt32> shape, int lastDimension) {
    *      operand representing a shape, followed by the dimensions of an operand representing a shape
    *      to append
    */
-  public <T extends TNumber> Operand<T> append(Operand<T> shape, Operand<T> shapeToAppend) {
+  public <T extends Tensor & TNumber> Operand<T> append(Operand<T> shape,
+      Operand<T> shapeToAppend) {
     return Shapes.append(scope, shape, shapeToAppend);
   }
 
@@ -90,7 +91,7 @@ public <T extends TNumber> Operand<T> append(Operand<T> shape, Operand<T> shapeT
    * @param operand the operand to flatten
    * @return the reshaped operand
    */
-  public <T extends TType> Operand<T> flatten(Operand<T> operand) {
+  public <T extends Tensor> Operand<T> flatten(Operand<T> operand) {
     return Shapes.flatten(scope, operand);
   }
 
@@ -115,7 +116,7 @@ public Operand<TInt32> flatten(Shape<TInt32> shape) {
    * @param dType the shape datatype
    * @return the reshaped operand
    */
-  public <T extends TType, U extends TNumber> Operand<T> flatten(Operand<T> operand,
+  public <T extends Tensor, U extends Tensor & TNumber> Operand<T> flatten(Operand<T> operand,
       DataType<U> dType) {
     return Shapes.flatten(scope, operand, dType);
   }
@@ -129,7 +130,7 @@ public <T extends TType, U extends TNumber> Operand<T> flatten(Operand<T> operan
    * @param dType the shape datatype
    * @return the flattened shape
    */
-  public <U extends TNumber> Operand<U> flatten(Shape<U> shape, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> flatten(Shape<U> shape, DataType<U> dType) {
     return Shapes.flatten(scope, shape, dType);
   }
 
@@ -153,7 +154,7 @@ public Operand<TInt32> head(Shape<TInt32> shape) {
    * @param <U> the shape datatype.
    * @return a 1-dimensional Operand containing the Shape's first dimension
    */
-  public <U extends TNumber> Operand<U> head(Shape<U> shape, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> head(Shape<U> shape, DataType<U> dType) {
     return Shapes.head(scope, shape, dType);
   }
 
@@ -177,7 +178,7 @@ public Operand<TInt32> numDimensions(Shape<TInt32> shape) {
    * @param dType the shape datatype
    * @return the number of dimensions
    */
-  public <U extends TNumber> Operand<U> numDimensions(Shape<U> shape, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> numDimensions(Shape<U> shape, DataType<U> dType) {
     return Shapes.numDimensions(scope, shape, dType);
   }
 
@@ -221,7 +222,8 @@ public Operand<TInt32> prepend(Shape<TInt32> shape, int firstDimension) {
    *      operand representing the shape to prepend, followed by the dimensions of an operand
    *      representing the shape
    */
-  public <T extends TNumber> Operand<T> prepend(Operand<T> shape, Operand<T> shapeToPrepend) {
+  public <T extends Tensor & TNumber> Operand<T> prepend(Operand<T> shape,
+      Operand<T> shapeToPrepend) {
     return Shapes.prepend(scope, shape, shapeToPrepend);
   }
 
@@ -234,7 +236,7 @@ public <T extends TNumber> Operand<T> prepend(Operand<T> shape, Operand<T> shape
    * @param axis the axis
    * @return the reshaped operand
    */
-  public <T extends TType> Operand<T> reduceDims(Operand<T> operand, Operand<TInt32> axis) {
+  public <T extends Tensor> Operand<T> reduceDims(Operand<T> operand, Operand<TInt32> axis) {
     return Shapes.reduceDims(scope, operand, axis);
   }
 
@@ -261,7 +263,7 @@ public Operand<TInt32> reduceDims(Shape<TInt32> shape, Operand<TInt32> axis) {
    * @param dType the shape datatype
    * @return the reshaped operand
    */
-  public <T extends TType, U extends TNumber> Operand<T> reduceDims(Operand<T> operand,
+  public <T extends Tensor, U extends Tensor & TNumber> Operand<T> reduceDims(Operand<T> operand,
       Operand<U> axis, DataType<U> dType) {
     return Shapes.reduceDims(scope, operand, axis, dType);
   }
@@ -276,7 +278,7 @@ public <T extends TType, U extends TNumber> Operand<T> reduceDims(Operand<T> ope
    * @param dType the shape datatype
    * @return the reduced shape
    */
-  public <U extends TNumber> Operand<U> reduceDims(Shape<U> shape, Operand<U> axis,
+  public <U extends Tensor & TNumber> Operand<U> reduceDims(Shape<U> shape, Operand<U> axis,
       DataType<U> dType) {
     return Shapes.reduceDims(scope, shape, axis, dType);
   }
@@ -300,7 +302,7 @@ public Operand<TInt32> size(Shape<TInt32> shape) {
    * @param dim the dimension
    * @return the size of the specified dimension
    */
-  public <T extends TType> Operand<TInt32> size(Operand<T> input, Operand<TInt32> dim) {
+  public <T extends Tensor> Operand<TInt32> size(Operand<T> input, Operand<TInt32> dim) {
     return Shapes.size(scope, input, dim);
   }
 
@@ -313,7 +315,7 @@ public <T extends TType> Operand<TInt32> size(Operand<T> input, Operand<TInt32>
    * @param dType the shape datatype
    * @return the size
    */
-  public <U extends TNumber> Operand<U> size(Shape<U> shape, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> size(Shape<U> shape, DataType<U> dType) {
     return Shapes.size(scope, shape, dType);
   }
 
@@ -339,8 +341,8 @@ public Operand<TInt32> size(Shape<TInt32> shape, Operand<TInt32> dim) {
    * @param dType the shape datatype
    * @return the size of the specified dimension
    */
-  public <T extends TType, U extends TNumber> Operand<U> size(Operand<T> input, Operand<U> dim,
-      DataType<U> dType) {
+  public <T extends Tensor, U extends Tensor & TNumber> Operand<U> size(Operand<T> input,
+      Operand<U> dim, DataType<U> dType) {
     return Shapes.size(scope, input, dim, dType);
   }
 
@@ -354,7 +356,8 @@ public <T extends TType, U extends TNumber> Operand<U> size(Operand<T> input, Op
    * @param dType the shape datatype
    * @return the size of the specified dimension
    */
-  public <U extends TNumber> Operand<U> size(Shape<U> shape, Operand<U> dim, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> size(Shape<U> shape, Operand<U> dim,
+      DataType<U> dType) {
     return Shapes.size(scope, shape, dim, dType);
   }
 
@@ -378,7 +381,7 @@ public Operand<TInt32> squeeze(Shape<TInt32> shape) {
    * @param dType the shape datatype.
    * @return the squeezed shape
    */
-  public <U extends TNumber> Operand<U> squeeze(Shape<U> shape, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> squeeze(Shape<U> shape, DataType<U> dType) {
     return Shapes.squeeze(scope, shape, dType);
   }
 
@@ -406,7 +409,7 @@ public Operand<TInt32> tail(Shape<TInt32> shape) {
    * @return a 1-dimensional Operand that contains the dimension matching the last dimension of the
    *      Shape
    */
-  public <U extends TNumber> Operand<U> tail(Shape<U> shape, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> tail(Shape<U> shape, DataType<U> dType) {
     return Shapes.tail(scope, shape, dType);
   }
 
@@ -436,7 +439,8 @@ public Operand<TInt32> take(Shape<TInt32> shape, Operand<TInt32> n) {
    * @return a 1-dimensional operand with the dimensions matching * the first n dimensions of the
    *      shape
    */
-  public <U extends TNumber> Operand<U> take(Shape<U> shape, Operand<U> n, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> take(Shape<U> shape, Operand<U> n,
+      DataType<U> dType) {
     return Shapes.take(scope, shape, n, dType);
   }
 
@@ -450,7 +454,8 @@ public <U extends TNumber> Operand<U> take(Shape<U> shape, Operand<U> n, DataTyp
    * @return a 1-dimensional operand containing the dimensions matching the last n dimensions of the
    *      shape
    */
-  public <U extends TNumber> Operand<TInt32> takeLast(Shape<TInt32> shape, Operand<TInt32> n) {
+  public <U extends Tensor & TNumber> Operand<TInt32> takeLast(Shape<TInt32> shape,
+      Operand<TInt32> n) {
     return Shapes.takeLast(scope, shape, n);
   }
 
@@ -466,7 +471,8 @@ public <U extends TNumber> Operand<TInt32> takeLast(Shape<TInt32> shape, Operand
    * @return a 1-dimensional operand containing the dimensions matching the last n dimensions of the
    *      shape
    */
-  public <U extends TNumber> Operand<U> takeLast(Shape<U> shape, Operand<U> n, DataType<U> dType) {
+  public <U extends Tensor & TNumber> Operand<U> takeLast(Shape<U> shape, Operand<U> n,
+      DataType<U> dType) {
     return Shapes.takeLast(scope, shape, n, dType);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java
index f4ec7bdb48d..c15b82120f0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java
@@ -19,6 +19,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.signal.BatchFft;
 import org.tensorflow.op.signal.BatchFft2d;
 import org.tensorflow.op.signal.BatchFft3d;
@@ -40,7 +41,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code signal} operations as {@link Op Op}s
@@ -118,7 +118,7 @@ public BatchIfft3d batchIfft3d(Operand<?> input) {
    * @param input A complex tensor.
    * @return a new instance of Fft
    */
-  public <T extends TType> Fft<T> fft(Operand<T> input) {
+  public <T extends Tensor> Fft<T> fft(Operand<T> input) {
     return Fft.create(scope, input);
   }
 
@@ -132,7 +132,7 @@ public <T extends TType> Fft<T> fft(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Fft2d
    */
-  public <T extends TType> Fft2d<T> fft2d(Operand<T> input) {
+  public <T extends Tensor> Fft2d<T> fft2d(Operand<T> input) {
     return Fft2d.create(scope, input);
   }
 
@@ -146,7 +146,7 @@ public <T extends TType> Fft2d<T> fft2d(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Fft3d
    */
-  public <T extends TType> Fft3d<T> fft3d(Operand<T> input) {
+  public <T extends Tensor> Fft3d<T> fft3d(Operand<T> input) {
     return Fft3d.create(scope, input);
   }
 
@@ -160,7 +160,7 @@ public <T extends TType> Fft3d<T> fft3d(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Ifft
    */
-  public <T extends TType> Ifft<T> ifft(Operand<T> input) {
+  public <T extends Tensor> Ifft<T> ifft(Operand<T> input) {
     return Ifft.create(scope, input);
   }
 
@@ -174,7 +174,7 @@ public <T extends TType> Ifft<T> ifft(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Ifft2d
    */
-  public <T extends TType> Ifft2d<T> ifft2d(Operand<T> input) {
+  public <T extends Tensor> Ifft2d<T> ifft2d(Operand<T> input) {
     return Ifft2d.create(scope, input);
   }
 
@@ -188,7 +188,7 @@ public <T extends TType> Ifft2d<T> ifft2d(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Ifft3d
    */
-  public <T extends TType> Ifft3d<T> ifft3d(Operand<T> input) {
+  public <T extends Tensor> Ifft3d<T> ifft3d(Operand<T> input) {
     return Ifft3d.create(scope, input);
   }
 
@@ -214,7 +214,7 @@ public <T extends TType> Ifft3d<T> ifft3d(Operand<T> input) {
    * @param fftLength An int32 tensor of shape [1]. The FFT length.
    * @return a new instance of Irfft
    */
-  public <T extends TType> Irfft<TFloat32> irfft(Operand<T> input, Operand<TInt32> fftLength) {
+  public <T extends Tensor> Irfft<TFloat32> irfft(Operand<T> input, Operand<TInt32> fftLength) {
     return Irfft.create(scope, input, fftLength);
   }
 
@@ -241,7 +241,7 @@ public <T extends TType> Irfft<TFloat32> irfft(Operand<T> input, Operand<TInt32>
    * @param Treal
    * @return a new instance of Irfft
    */
-  public <U extends TNumber, T extends TType> Irfft<U> irfft(Operand<T> input,
+  public <U extends Tensor & TNumber, T extends Tensor> Irfft<U> irfft(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Treal) {
     return Irfft.create(scope, input, fftLength, Treal);
   }
@@ -269,7 +269,7 @@ public <U extends TNumber, T extends TType> Irfft<U> irfft(Operand<T> input,
    * @param fftLength An int32 tensor of shape [2]. The FFT length for each dimension.
    * @return a new instance of Irfft2d
    */
-  public <T extends TType> Irfft2d<TFloat32> irfft2d(Operand<T> input, Operand<TInt32> fftLength) {
+  public <T extends Tensor> Irfft2d<TFloat32> irfft2d(Operand<T> input, Operand<TInt32> fftLength) {
     return Irfft2d.create(scope, input, fftLength);
   }
 
@@ -297,7 +297,7 @@ public <T extends TType> Irfft2d<TFloat32> irfft2d(Operand<T> input, Operand<TIn
    * @param Treal
    * @return a new instance of Irfft2d
    */
-  public <U extends TNumber, T extends TType> Irfft2d<U> irfft2d(Operand<T> input,
+  public <U extends Tensor & TNumber, T extends Tensor> Irfft2d<U> irfft2d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Treal) {
     return Irfft2d.create(scope, input, fftLength, Treal);
   }
@@ -325,7 +325,7 @@ public <U extends TNumber, T extends TType> Irfft2d<U> irfft2d(Operand<T> input,
    * @param fftLength An int32 tensor of shape [3]. The FFT length for each dimension.
    * @return a new instance of Irfft3d
    */
-  public <T extends TType> Irfft3d<TFloat32> irfft3d(Operand<T> input, Operand<TInt32> fftLength) {
+  public <T extends Tensor> Irfft3d<TFloat32> irfft3d(Operand<T> input, Operand<TInt32> fftLength) {
     return Irfft3d.create(scope, input, fftLength);
   }
 
@@ -353,7 +353,7 @@ public <T extends TType> Irfft3d<TFloat32> irfft3d(Operand<T> input, Operand<TIn
    * @param Treal
    * @return a new instance of Irfft3d
    */
-  public <U extends TNumber, T extends TType> Irfft3d<U> irfft3d(Operand<T> input,
+  public <U extends Tensor & TNumber, T extends Tensor> Irfft3d<U> irfft3d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Treal) {
     return Irfft3d.create(scope, input, fftLength, Treal);
   }
@@ -378,7 +378,7 @@ public <U extends TNumber, T extends TType> Irfft3d<U> irfft3d(Operand<T> input,
    * @param Tcomplex
    * @return a new instance of Rfft
    */
-  public <U extends TType, T extends TNumber> Rfft<U> rfft(Operand<T> input,
+  public <U extends Tensor, T extends Tensor & TNumber> Rfft<U> rfft(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     return Rfft.create(scope, input, fftLength, Tcomplex);
   }
@@ -404,7 +404,7 @@ public <U extends TType, T extends TNumber> Rfft<U> rfft(Operand<T> input,
    * @param Tcomplex
    * @return a new instance of Rfft2d
    */
-  public <U extends TType, T extends TNumber> Rfft2d<U> rfft2d(Operand<T> input,
+  public <U extends Tensor, T extends Tensor & TNumber> Rfft2d<U> rfft2d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     return Rfft2d.create(scope, input, fftLength, Tcomplex);
   }
@@ -430,7 +430,7 @@ public <U extends TType, T extends TNumber> Rfft2d<U> rfft2d(Operand<T> input,
    * @param Tcomplex
    * @return a new instance of Rfft3d
    */
-  public <U extends TType, T extends TNumber> Rfft3d<U> rfft3d(Operand<T> input,
+  public <U extends Tensor, T extends Tensor & TNumber> Rfft3d<U> rfft3d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     return Rfft3d.create(scope, input, fftLength, Tcomplex);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java
index 6e26fec2275..d8ba9f45ef2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java
@@ -19,6 +19,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.sparse.AddManySparseToTensorsMap;
 import org.tensorflow.op.sparse.AddSparseToTensorsMap;
@@ -67,7 +68,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code sparse} operations as {@link Op Op}s
@@ -114,7 +114,7 @@ public final class SparseOps {
    * @param options carries optional attributes values
    * @return a new instance of AddManySparseToTensorsMap
    */
-  public <T extends TType> AddManySparseToTensorsMap addManySparseToTensorsMap(
+  public <T extends Tensor> AddManySparseToTensorsMap addManySparseToTensorsMap(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       AddManySparseToTensorsMap.Options... options) {
     return AddManySparseToTensorsMap.create(scope, sparseIndices, sparseValues, sparseShape, options);
@@ -144,7 +144,7 @@ public <T extends TType> AddManySparseToTensorsMap addManySparseToTensorsMap(
    * @param options carries optional attributes values
    * @return a new instance of AddSparseToTensorsMap
    */
-  public <T extends TType> AddSparseToTensorsMap addSparseToTensorsMap(
+  public <T extends Tensor> AddSparseToTensorsMap addSparseToTensorsMap(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       AddSparseToTensorsMap.Options... options) {
     return AddSparseToTensorsMap.create(scope, sparseIndices, sparseValues, sparseShape, options);
@@ -170,7 +170,7 @@ public <T extends TType> AddSparseToTensorsMap addSparseToTensorsMap(
    * @param options carries optional attributes values
    * @return a new instance of DenseToDenseSetOperation
    */
-  public <T extends TType> DenseToDenseSetOperation<T> denseToDenseSetOperation(Operand<T> set1,
+  public <T extends Tensor> DenseToDenseSetOperation<T> denseToDenseSetOperation(Operand<T> set1,
       Operand<T> set2, String setOperation, DenseToDenseSetOperation.Options... options) {
     return DenseToDenseSetOperation.create(scope, set1, set2, setOperation, options);
   }
@@ -208,7 +208,7 @@ public <T extends TType> DenseToDenseSetOperation<T> denseToDenseSetOperation(Op
    * @param options carries optional attributes values
    * @return a new instance of DenseToSparseSetOperation
    */
-  public <T extends TType> DenseToSparseSetOperation<T> denseToSparseSetOperation(Operand<T> set1,
+  public <T extends Tensor> DenseToSparseSetOperation<T> denseToSparseSetOperation(Operand<T> set1,
       Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape,
       String setOperation, DenseToSparseSetOperation.Options... options) {
     return DenseToSparseSetOperation.create(scope, set1, set2Indices, set2Values, set2Shape, setOperation, options);
@@ -265,7 +265,7 @@ public <T extends TType> DenseToSparseSetOperation<T> denseToSparseSetOperation(
    * @param dtype The `dtype` of the serialized `SparseTensor` objects.
    * @return a new instance of DeserializeSparse
    */
-  public <U extends TType, T extends TType> DeserializeSparse<U> deserializeSparse(
+  public <U extends Tensor, T extends Tensor> DeserializeSparse<U> deserializeSparse(
       Operand<T> serializedSparse, DataType<U> dtype) {
     return DeserializeSparse.create(scope, serializedSparse, dtype);
   }
@@ -288,7 +288,7 @@ public <U extends TType, T extends TType> DeserializeSparse<U> deserializeSparse
    *  case the input is ignored during validation.
    * @return a new instance of SparseAccumulatorApplyGradient
    */
-  public <T extends TType> SparseAccumulatorApplyGradient sparseAccumulatorApplyGradient(
+  public <T extends Tensor> SparseAccumulatorApplyGradient sparseAccumulatorApplyGradient(
       Operand<TString> handle, Operand<TInt64> localStep, Operand<TInt64> gradientIndices,
       Operand<T> gradientValues, Operand<TInt64> gradientShape, Boolean hasKnownShape) {
     return SparseAccumulatorApplyGradient.create(scope, handle, localStep, gradientIndices, gradientValues, gradientShape, hasKnownShape);
@@ -311,7 +311,7 @@ public <T extends TType> SparseAccumulatorApplyGradient sparseAccumulatorApplyGr
    *  of the accumulator.
    * @return a new instance of SparseAccumulatorTakeGradient
    */
-  public <T extends TType> SparseAccumulatorTakeGradient<T> sparseAccumulatorTakeGradient(
+  public <T extends Tensor> SparseAccumulatorTakeGradient<T> sparseAccumulatorTakeGradient(
       Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     return SparseAccumulatorTakeGradient.create(scope, handle, numRequired, dtype);
   }
@@ -344,9 +344,9 @@ public <T extends TType> SparseAccumulatorTakeGradient<T> sparseAccumulatorTakeG
    *  pair takes space.
    * @return a new instance of SparseAdd
    */
-  public <T extends TType, U extends TNumber> SparseAdd<T> sparseAdd(Operand<TInt64> aIndices,
-      Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues,
-      Operand<TInt64> bShape, Operand<U> thresh) {
+  public <T extends Tensor, U extends Tensor & TNumber> SparseAdd<T> sparseAdd(
+      Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape,
+      Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape, Operand<U> thresh) {
     return SparseAdd.create(scope, aIndices, aValues, aShape, bIndices, bValues, bShape, thresh);
   }
 
@@ -367,7 +367,7 @@ public <T extends TType, U extends TNumber> SparseAdd<T> sparseAdd(Operand<TInt6
    *  `[nnz(sum), ndims]`.
    * @return a new instance of SparseAddGrad
    */
-  public <T extends TType> SparseAddGrad<T> sparseAddGrad(Operand<T> backpropValGrad,
+  public <T extends Tensor> SparseAddGrad<T> sparseAddGrad(Operand<T> backpropValGrad,
       Operand<TInt64> aIndices, Operand<TInt64> bIndices, Operand<TInt64> sumIndices) {
     return SparseAddGrad.create(scope, backpropValGrad, aIndices, bIndices, sumIndices);
   }
@@ -425,7 +425,7 @@ public <T extends TType> SparseAddGrad<T> sparseAddGrad(Operand<T> backpropValGr
    *  where rank is the number of dimensions in each input `SparseTensor`.
    * @return a new instance of SparseConcat
    */
-  public <T extends TType> SparseConcat<T> sparseConcat(Iterable<Operand<TInt64>> indices,
+  public <T extends Tensor> SparseConcat<T> sparseConcat(Iterable<Operand<TInt64>> indices,
       Iterable<Operand<T>> values, Iterable<Operand<TInt64>> shapes, Long concatDim) {
     return SparseConcat.create(scope, indices, values, shapes, concatDim);
   }
@@ -445,7 +445,7 @@ public <T extends TType> SparseConcat<T> sparseConcat(Iterable<Operand<TInt64>>
    * @param options carries optional attributes values
    * @return a new instance of SparseConditionalAccumulator
    */
-  public <T extends TType> SparseConditionalAccumulator sparseConditionalAccumulator(
+  public <T extends Tensor> SparseConditionalAccumulator sparseConditionalAccumulator(
       DataType<T> dtype, Shape shape, SparseConditionalAccumulator.Options... options) {
     return SparseConditionalAccumulator.create(scope, dtype, shape, options);
   }
@@ -505,7 +505,7 @@ public <T extends TType> SparseConditionalAccumulator sparseConditionalAccumulat
    * @param internalType
    * @return a new instance of SparseCross
    */
-  public <T extends TType, U extends TType> SparseCross<T> sparseCross(
+  public <T extends Tensor, U extends Tensor> SparseCross<T> sparseCross(
       Iterable<Operand<TInt64>> indices, Iterable<Operand<?>> values,
       Iterable<Operand<TInt64>> shapes, Iterable<Operand<?>> denseInputs, Boolean hashedOutput,
       Long numBuckets, Long hashKey, DataType<T> outType, DataType<U> internalType) {
@@ -532,7 +532,7 @@ public <T extends TType, U extends TType> SparseCross<T> sparseCross(
    * @param dense `R`-D.  The dense Tensor operand.
    * @return a new instance of SparseDenseCwiseAdd
    */
-  public <T extends TType> SparseDenseCwiseAdd<T> sparseDenseCwiseAdd(Operand<TInt64> spIndices,
+  public <T extends Tensor> SparseDenseCwiseAdd<T> sparseDenseCwiseAdd(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     return SparseDenseCwiseAdd.create(scope, spIndices, spValues, spShape, dense);
   }
@@ -551,7 +551,7 @@ public <T extends TType> SparseDenseCwiseAdd<T> sparseDenseCwiseAdd(Operand<TInt
    * @param dense `R`-D.  The dense Tensor operand.
    * @return a new instance of SparseDenseCwiseDiv
    */
-  public <T extends TType> SparseDenseCwiseDiv<T> sparseDenseCwiseDiv(Operand<TInt64> spIndices,
+  public <T extends Tensor> SparseDenseCwiseDiv<T> sparseDenseCwiseDiv(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     return SparseDenseCwiseDiv.create(scope, spIndices, spValues, spShape, dense);
   }
@@ -574,7 +574,7 @@ public <T extends TType> SparseDenseCwiseDiv<T> sparseDenseCwiseDiv(Operand<TInt
    * @param dense `R`-D.  The dense Tensor operand.
    * @return a new instance of SparseDenseCwiseMul
    */
-  public <T extends TType> SparseDenseCwiseMul<T> sparseDenseCwiseMul(Operand<TInt64> spIndices,
+  public <T extends Tensor> SparseDenseCwiseMul<T> sparseDenseCwiseMul(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     return SparseDenseCwiseMul.create(scope, spIndices, spValues, spShape, dense);
   }
@@ -628,7 +628,7 @@ public <T extends TType> SparseDenseCwiseMul<T> sparseDenseCwiseMul(Operand<TInt
    *  output indices: 2-D. the indices of the filled sparse tensor.
    * @return a new instance of SparseFillEmptyRows
    */
-  public <T extends TType> SparseFillEmptyRows<T> sparseFillEmptyRows(Operand<TInt64> indices,
+  public <T extends Tensor> SparseFillEmptyRows<T> sparseFillEmptyRows(Operand<TInt64> indices,
       Operand<T> values, Operand<TInt64> denseShape, Operand<T> defaultValue) {
     return SparseFillEmptyRows.create(scope, indices, values, denseShape, defaultValue);
   }
@@ -650,7 +650,7 @@ public <T extends TType> SparseFillEmptyRows<T> sparseFillEmptyRows(Operand<TInt
    * @param gradValues 1-D.  The gradients from backprop.
    * @return a new instance of SparseFillEmptyRowsGrad
    */
-  public <T extends TType> SparseFillEmptyRowsGrad<T> sparseFillEmptyRowsGrad(
+  public <T extends Tensor> SparseFillEmptyRowsGrad<T> sparseFillEmptyRowsGrad(
       Operand<TInt64> reverseIndexMap, Operand<T> gradValues) {
     return SparseFillEmptyRowsGrad.create(scope, reverseIndexMap, gradValues);
   }
@@ -673,8 +673,8 @@ public <T extends TType> SparseFillEmptyRowsGrad<T> sparseFillEmptyRowsGrad(
    * @param options carries optional attributes values
    * @return a new instance of SparseMatMul
    */
-  public <T extends TNumber, U extends TNumber> SparseMatMul sparseMatMul(Operand<T> a,
-      Operand<U> b, SparseMatMul.Options... options) {
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseMatMul sparseMatMul(
+      Operand<T> a, Operand<U> b, SparseMatMul.Options... options) {
     return SparseMatMul.create(scope, a, b, options);
   }
 
@@ -703,9 +703,9 @@ public <T extends TNumber, U extends TNumber> SparseMatMul sparseMatMul(Operand<
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceMax
    */
-  public <T extends TNumber> SparseReduceMax<T> sparseReduceMax(Operand<TInt64> inputIndices,
-      Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes,
-      SparseReduceMax.Options... options) {
+  public <T extends Tensor & TNumber> SparseReduceMax<T> sparseReduceMax(
+      Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape,
+      Operand<TInt32> reductionAxes, SparseReduceMax.Options... options) {
     return SparseReduceMax.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
   }
 
@@ -734,7 +734,7 @@ public <T extends TNumber> SparseReduceMax<T> sparseReduceMax(Operand<TInt64> in
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceMaxSparse
    */
-  public <T extends TNumber> SparseReduceMaxSparse<T> sparseReduceMaxSparse(
+  public <T extends Tensor & TNumber> SparseReduceMaxSparse<T> sparseReduceMaxSparse(
       Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape,
       Operand<TInt32> reductionAxes, SparseReduceMaxSparse.Options... options) {
     return SparseReduceMaxSparse.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
@@ -765,7 +765,7 @@ public <T extends TNumber> SparseReduceMaxSparse<T> sparseReduceMaxSparse(
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceSum
    */
-  public <T extends TType> SparseReduceSum<T> sparseReduceSum(Operand<TInt64> inputIndices,
+  public <T extends Tensor> SparseReduceSum<T> sparseReduceSum(Operand<TInt64> inputIndices,
       Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes,
       SparseReduceSum.Options... options) {
     return SparseReduceSum.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
@@ -796,7 +796,7 @@ public <T extends TType> SparseReduceSum<T> sparseReduceSum(Operand<TInt64> inpu
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceSumSparse
    */
-  public <T extends TType> SparseReduceSumSparse<T> sparseReduceSumSparse(
+  public <T extends Tensor> SparseReduceSumSparse<T> sparseReduceSumSparse(
       Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape,
       Operand<TInt32> reductionAxes, SparseReduceSumSparse.Options... options) {
     return SparseReduceSumSparse.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
@@ -821,7 +821,7 @@ public <T extends TType> SparseReduceSumSparse<T> sparseReduceSumSparse(
    * @param inputShape 1-D.  Shape of the input SparseTensor.
    * @return a new instance of SparseReorder
    */
-  public <T extends TType> SparseReorder<T> sparseReorder(Operand<TInt64> inputIndices,
+  public <T extends Tensor> SparseReorder<T> sparseReorder(Operand<TInt64> inputIndices,
       Operand<T> inputValues, Operand<TInt64> inputShape) {
     return SparseReorder.create(scope, inputIndices, inputValues, inputShape);
   }
@@ -870,7 +870,7 @@ public SparseReshape sparseReshape(Operand<TInt64> inputIndices, Operand<TInt64>
    * @param segmentIds A 1-D tensor. Values should be sorted and can be repeated.
    * @return a new instance of SparseSegmentMean
    */
-  public <T extends TNumber, U extends TNumber> SparseSegmentMean<T> sparseSegmentMean(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMean<T> sparseSegmentMean(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     return SparseSegmentMean.create(scope, data, indices, segmentIds);
   }
@@ -888,7 +888,7 @@ public <T extends TNumber, U extends TNumber> SparseSegmentMean<T> sparseSegment
    * @param outputDim0 dimension 0 of "data" passed to SparseSegmentMean op.
    * @return a new instance of SparseSegmentMeanGrad
    */
-  public <T extends TNumber, U extends TNumber> SparseSegmentMeanGrad<T> sparseSegmentMeanGrad(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMeanGrad<T> sparseSegmentMeanGrad(
       Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     return SparseSegmentMeanGrad.create(scope, grad, indices, segmentIds, outputDim0);
   }
@@ -910,7 +910,7 @@ public <T extends TNumber, U extends TNumber> SparseSegmentMeanGrad<T> sparseSeg
    * @param numSegments Should equal the number of distinct segment IDs.
    * @return a new instance of SparseSegmentMeanWithNumSegments
    */
-  public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentMeanWithNumSegments<T> sparseSegmentMeanWithNumSegments(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentMeanWithNumSegments<T> sparseSegmentMeanWithNumSegments(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     return SparseSegmentMeanWithNumSegments.create(scope, data, indices, segmentIds, numSegments);
   }
@@ -928,7 +928,7 @@ public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentMe
    * @param segmentIds A 1-D tensor. Values should be sorted and can be repeated.
    * @return a new instance of SparseSegmentSqrtN
    */
-  public <T extends TNumber, U extends TNumber> SparseSegmentSqrtN<T> sparseSegmentSqrtN(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtN<T> sparseSegmentSqrtN(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     return SparseSegmentSqrtN.create(scope, data, indices, segmentIds);
   }
@@ -946,7 +946,7 @@ public <T extends TNumber, U extends TNumber> SparseSegmentSqrtN<T> sparseSegmen
    * @param outputDim0 dimension 0 of "data" passed to SparseSegmentSqrtN op.
    * @return a new instance of SparseSegmentSqrtNGrad
    */
-  public <T extends TNumber, U extends TNumber> SparseSegmentSqrtNGrad<T> sparseSegmentSqrtNGrad(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtNGrad<T> sparseSegmentSqrtNGrad(
       Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     return SparseSegmentSqrtNGrad.create(scope, grad, indices, segmentIds, outputDim0);
   }
@@ -970,7 +970,7 @@ public <T extends TNumber, U extends TNumber> SparseSegmentSqrtNGrad<T> sparseSe
    * @param numSegments Should equal the number of distinct segment IDs.
    * @return a new instance of SparseSegmentSqrtNWithNumSegments
    */
-  public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSqrtNWithNumSegments<T> sparseSegmentSqrtNWithNumSegments(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSqrtNWithNumSegments<T> sparseSegmentSqrtNWithNumSegments(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     return SparseSegmentSqrtNWithNumSegments.create(scope, data, indices, segmentIds, numSegments);
   }
@@ -1013,7 +1013,7 @@ public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSq
    * @param segmentIds A 1-D tensor. Values should be sorted and can be repeated.
    * @return a new instance of SparseSegmentSum
    */
-  public <T extends TNumber, U extends TNumber> SparseSegmentSum<T> sparseSegmentSum(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSum<T> sparseSegmentSum(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     return SparseSegmentSum.create(scope, data, indices, segmentIds);
   }
@@ -1055,7 +1055,7 @@ public <T extends TNumber, U extends TNumber> SparseSegmentSum<T> sparseSegmentS
    * @param numSegments Should equal the number of distinct segment IDs.
    * @return a new instance of SparseSegmentSumWithNumSegments
    */
-  public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSumWithNumSegments<T> sparseSegmentSumWithNumSegments(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSumWithNumSegments<T> sparseSegmentSumWithNumSegments(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     return SparseSegmentSumWithNumSegments.create(scope, data, indices, segmentIds, numSegments);
   }
@@ -1089,7 +1089,7 @@ public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSu
    *  sparse tensors.
    * @return a new instance of SparseSlice
    */
-  public <T extends TType> SparseSlice<T> sparseSlice(Operand<TInt64> indices, Operand<T> values,
+  public <T extends Tensor> SparseSlice<T> sparseSlice(Operand<TInt64> indices, Operand<T> values,
       Operand<TInt64> shape, Operand<TInt64> start, Operand<TInt64> size) {
     return SparseSlice.create(scope, indices, values, shape, start, size);
   }
@@ -1109,7 +1109,7 @@ public <T extends TType> SparseSlice<T> sparseSlice(Operand<TInt64> indices, Ope
    * @param outputIndices 2-D.  The `indices` of the sliced `SparseTensor`.
    * @return a new instance of SparseSliceGrad
    */
-  public <T extends TType> SparseSliceGrad<T> sparseSliceGrad(Operand<T> backpropValGrad,
+  public <T extends Tensor> SparseSliceGrad<T> sparseSliceGrad(Operand<T> backpropValGrad,
       Operand<TInt64> inputIndices, Operand<TInt64> inputStart, Operand<TInt64> outputIndices) {
     return SparseSliceGrad.create(scope, backpropValGrad, inputIndices, inputStart, outputIndices);
   }
@@ -1140,7 +1140,7 @@ public <T extends TType> SparseSliceGrad<T> sparseSliceGrad(Operand<T> backpropV
    * @param spShape 1-D.  Shape of the input SparseTensor.
    * @return a new instance of SparseSoftmax
    */
-  public <T extends TNumber> SparseSoftmax<T> sparseSoftmax(Operand<TInt64> spIndices,
+  public <T extends Tensor & TNumber> SparseSoftmax<T> sparseSoftmax(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape) {
     return SparseSoftmax.create(scope, spIndices, spValues, spShape);
   }
@@ -1160,9 +1160,9 @@ public <T extends TNumber> SparseSoftmax<T> sparseSoftmax(Operand<TInt64> spIndi
    * @param bShape counterpart to `a_shape` for the other operand; the two shapes must be equal.
    * @return a new instance of SparseSparseMaximum
    */
-  public <T extends TNumber> SparseSparseMaximum<T> sparseSparseMaximum(Operand<TInt64> aIndices,
-      Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues,
-      Operand<TInt64> bShape) {
+  public <T extends Tensor & TNumber> SparseSparseMaximum<T> sparseSparseMaximum(
+      Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape,
+      Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
     return SparseSparseMaximum.create(scope, aIndices, aValues, aShape, bIndices, bValues, bShape);
   }
 
@@ -1181,7 +1181,7 @@ public <T extends TNumber> SparseSparseMaximum<T> sparseSparseMaximum(Operand<TI
    * @param bShape counterpart to `a_shape` for the other operand; the two shapes must be equal.
    * @return a new instance of SparseSparseMinimum
    */
-  public <T extends TType> SparseSparseMinimum<T> sparseSparseMinimum(Operand<TInt64> aIndices,
+  public <T extends Tensor> SparseSparseMinimum<T> sparseSparseMinimum(Operand<TInt64> aIndices,
       Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues,
       Operand<TInt64> bShape) {
     return SparseSparseMinimum.create(scope, aIndices, aValues, aShape, bIndices, bValues, bShape);
@@ -1219,7 +1219,7 @@ public <T extends TType> SparseSparseMinimum<T> sparseSparseMinimum(Operand<TInt
    * @param numSplit The number of ways to split.
    * @return a new instance of SparseSplit
    */
-  public <T extends TType> SparseSplit<T> sparseSplit(Operand<TInt64> splitDim,
+  public <T extends Tensor> SparseSplit<T> sparseSplit(Operand<TInt64> splitDim,
       Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Long numSplit) {
     return SparseSplit.create(scope, splitDim, indices, values, shape, numSplit);
   }
@@ -1236,7 +1236,7 @@ public <T extends TType> SparseSplit<T> sparseSplit(Operand<TInt64> splitDim,
    * @param b `ndims`-D Tensor.  With shape `a_shape`.
    * @return a new instance of SparseTensorDenseAdd
    */
-  public <U extends TType, T extends TNumber> SparseTensorDenseAdd<U> sparseTensorDenseAdd(
+  public <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseAdd<U> sparseTensorDenseAdd(
       Operand<T> aIndices, Operand<U> aValues, Operand<T> aShape, Operand<U> b) {
     return SparseTensorDenseAdd.create(scope, aIndices, aValues, aShape, b);
   }
@@ -1262,7 +1262,7 @@ public <U extends TType, T extends TNumber> SparseTensorDenseAdd<U> sparseTensor
    * @param options carries optional attributes values
    * @return a new instance of SparseTensorDenseMatMul
    */
-  public <U extends TType, T extends TNumber> SparseTensorDenseMatMul<U> sparseTensorDenseMatMul(
+  public <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseMatMul<U> sparseTensorDenseMatMul(
       Operand<T> aIndices, Operand<U> aValues, Operand<TInt64> aShape, Operand<U> b,
       SparseTensorDenseMatMul.Options... options) {
     return SparseTensorDenseMatMul.create(scope, aIndices, aValues, aShape, b, options);
@@ -1300,7 +1300,7 @@ public <U extends TType, T extends TNumber> SparseTensorDenseMatMul<U> sparseTen
    * @param options carries optional attributes values
    * @return a new instance of SparseToDense
    */
-  public <U extends TType, T extends TNumber> SparseToDense<U> sparseToDense(
+  public <U extends Tensor, T extends Tensor & TNumber> SparseToDense<U> sparseToDense(
       Operand<T> sparseIndices, Operand<T> outputShape, Operand<U> sparseValues,
       Operand<U> defaultValue, SparseToDense.Options... options) {
     return SparseToDense.create(scope, sparseIndices, outputShape, sparseValues, defaultValue, options);
@@ -1352,7 +1352,7 @@ public <U extends TType, T extends TNumber> SparseToDense<U> sparseToDense(
    * @param options carries optional attributes values
    * @return a new instance of SparseToSparseSetOperation
    */
-  public <T extends TType> SparseToSparseSetOperation<T> sparseToSparseSetOperation(
+  public <T extends Tensor> SparseToSparseSetOperation<T> sparseToSparseSetOperation(
       Operand<TInt64> set1Indices, Operand<T> set1Values, Operand<TInt64> set1Shape,
       Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape,
       String setOperation, SparseToSparseSetOperation.Options... options) {
@@ -1414,7 +1414,7 @@ public <T extends TType> SparseToSparseSetOperation<T> sparseToSparseSetOperatio
    * @param options carries optional attributes values
    * @return a new instance of TakeManySparseFromTensorsMap
    */
-  public <T extends TType> TakeManySparseFromTensorsMap<T> takeManySparseFromTensorsMap(
+  public <T extends Tensor> TakeManySparseFromTensorsMap<T> takeManySparseFromTensorsMap(
       Operand<TInt64> sparseHandles, DataType<T> dtype,
       TakeManySparseFromTensorsMap.Options... options) {
     return TakeManySparseFromTensorsMap.create(scope, sparseHandles, dtype, options);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java
index 75659ed60be..7b0fca54355 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java
@@ -20,6 +20,7 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.strings.Join;
 import org.tensorflow.op.strings.Lower;
 import org.tensorflow.op.strings.ReduceJoin;
@@ -230,7 +231,7 @@ public StringLength stringLength(Operand<TString> input, StringLength.Options...
    * @param preserveShortSequences
    * @return a new instance of StringNGrams
    */
-  public <T extends TNumber> StringNGrams<T> stringNGrams(Operand<TString> data,
+  public <T extends Tensor & TNumber> StringNGrams<T> stringNGrams(Operand<TString> data,
       Operand<T> dataSplits, String separator, List<Long> ngramWidths, String leftPad,
       String rightPad, Long padWidth, Boolean preserveShortSequences) {
     return StringNGrams.create(scope, data, dataSplits, separator, ngramWidths, leftPad, rightPad, padWidth, preserveShortSequences);
@@ -367,8 +368,8 @@ public Strip strip(Operand<TString> input) {
    * @param options carries optional attributes values
    * @return a new instance of Substr
    */
-  public <T extends TNumber> Substr substr(Operand<TString> input, Operand<T> pos, Operand<T> len,
-      Substr.Options... options) {
+  public <T extends Tensor & TNumber> Substr substr(Operand<TString> input, Operand<T> pos,
+      Operand<T> len, Substr.Options... options) {
     return Substr.create(scope, input, pos, len, options);
   }
 
@@ -483,7 +484,7 @@ public ToNumber<TFloat32> toNumber(Operand<TString> stringTensor) {
    * @param outType The numeric type to interpret each string in `string_tensor` as.
    * @return a new instance of ToNumber
    */
-  public <T extends TNumber> ToNumber<T> toNumber(Operand<TString> stringTensor,
+  public <T extends Tensor & TNumber> ToNumber<T> toNumber(Operand<TString> stringTensor,
       DataType<T> outType) {
     return ToNumber.create(scope, stringTensor, outType);
   }
@@ -596,7 +597,7 @@ public UnicodeTranscode unicodeTranscode(Operand<TString> input, String inputEnc
    * @param options carries optional attributes values
    * @return a new instance of UnsortedSegmentJoin
    */
-  public <T extends TNumber, U extends TNumber> UnsortedSegmentJoin unsortedSegmentJoin(
+  public <T extends Tensor & TNumber, U extends Tensor & TNumber> UnsortedSegmentJoin unsortedSegmentJoin(
       Operand<TString> inputs, Operand<T> segmentIds, Operand<U> numSegments,
       UnsortedSegmentJoin.Options... options) {
     return UnsortedSegmentJoin.create(scope, inputs, segmentIds, numSegments, options);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java
index 6143335b8fd..ce8b445610d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java
@@ -18,6 +18,7 @@
 package org.tensorflow.op;
 
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.summary.AudioSummary;
 import org.tensorflow.op.summary.HistogramSummary;
 import org.tensorflow.op.summary.ImageSummary;
@@ -27,7 +28,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code summary} operations as {@link Op Op}s
@@ -83,7 +83,7 @@ public AudioSummary audioSummary(Operand<TString> tag, Operand<TFloat32> tensor,
    * @param values Any shape. Values to use to build the histogram.
    * @return a new instance of HistogramSummary
    */
-  public <T extends TNumber> HistogramSummary histogramSummary(Operand<TString> tag,
+  public <T extends Tensor & TNumber> HistogramSummary histogramSummary(Operand<TString> tag,
       Operand<T> values) {
     return HistogramSummary.create(scope, tag, values);
   }
@@ -144,8 +144,8 @@ public <T extends TNumber> HistogramSummary histogramSummary(Operand<TString> ta
    * @param options carries optional attributes values
    * @return a new instance of ImageSummary
    */
-  public <T extends TNumber> ImageSummary imageSummary(Operand<TString> tag, Operand<T> tensor,
-      ImageSummary.Options... options) {
+  public <T extends Tensor & TNumber> ImageSummary imageSummary(Operand<TString> tag,
+      Operand<T> tensor, ImageSummary.Options... options) {
     return ImageSummary.create(scope, tag, tensor, options);
   }
 
@@ -178,7 +178,8 @@ public MergeSummary mergeSummary(Iterable<Operand<TString>> inputs) {
    * @param values Same shape as `tags.  Values for the summary.
    * @return a new instance of ScalarSummary
    */
-  public <T extends TNumber> ScalarSummary scalarSummary(Operand<TString> tags, Operand<T> values) {
+  public <T extends Tensor & TNumber> ScalarSummary scalarSummary(Operand<TString> tags,
+      Operand<T> values) {
     return ScalarSummary.create(scope, tags, values);
   }
 
@@ -191,7 +192,7 @@ public <T extends TNumber> ScalarSummary scalarSummary(Operand<TString> tags, Op
    *  data.
    * @return a new instance of TensorSummary
    */
-  public <T extends TType> TensorSummary tensorSummary(Operand<TString> tag, Operand<T> tensor,
+  public <T extends Tensor> TensorSummary tensorSummary(Operand<TString> tag, Operand<T> tensor,
       Operand<TString> serializedSummaryMetadata) {
     return TensorSummary.create(scope, tag, tensor, serializedSummaryMetadata);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java
index daf89645f2c..335dba78fb2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java
@@ -20,6 +20,7 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.train.AccumulatorApplyGradient;
 import org.tensorflow.op.train.AccumulatorNumAccumulated;
@@ -88,7 +89,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code train} operations as {@link Op Op}s
@@ -112,7 +112,7 @@ public final class TrainOps {
    * @param gradient A tensor of the gradient to be accumulated.
    * @return a new instance of AccumulatorApplyGradient
    */
-  public <T extends TType> AccumulatorApplyGradient accumulatorApplyGradient(
+  public <T extends Tensor> AccumulatorApplyGradient accumulatorApplyGradient(
       Operand<TString> handle, Operand<TInt64> localStep, Operand<T> gradient) {
     return AccumulatorApplyGradient.create(scope, handle, localStep, gradient);
   }
@@ -158,7 +158,7 @@ public AccumulatorSetGlobalStep accumulatorSetGlobalStep(Operand<TString> handle
    *  of the accumulator.
    * @return a new instance of AccumulatorTakeGradient
    */
-  public <T extends TType> AccumulatorTakeGradient<T> accumulatorTakeGradient(
+  public <T extends Tensor> AccumulatorTakeGradient<T> accumulatorTakeGradient(
       Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     return AccumulatorTakeGradient.create(scope, handle, numRequired, dtype);
   }
@@ -182,7 +182,7 @@ public <T extends TType> AccumulatorTakeGradient<T> accumulatorTakeGradient(
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdadelta
    */
-  public <T extends TType> ApplyAdadelta<T> applyAdadelta(Operand<T> var, Operand<T> accum,
+  public <T extends Tensor> ApplyAdadelta<T> applyAdadelta(Operand<T> var, Operand<T> accum,
       Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad,
       ApplyAdadelta.Options... options) {
     return ApplyAdadelta.create(scope, var, accum, accumUpdate, lr, rho, epsilon, grad, options);
@@ -202,7 +202,7 @@ public <T extends TType> ApplyAdadelta<T> applyAdadelta(Operand<T> var, Operand<
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdagrad
    */
-  public <T extends TType> ApplyAdagrad<T> applyAdagrad(Operand<T> var, Operand<T> accum,
+  public <T extends Tensor> ApplyAdagrad<T> applyAdagrad(Operand<T> var, Operand<T> accum,
       Operand<T> lr, Operand<T> grad, ApplyAdagrad.Options... options) {
     return ApplyAdagrad.create(scope, var, accum, lr, grad, options);
   }
@@ -222,7 +222,7 @@ public <T extends TType> ApplyAdagrad<T> applyAdagrad(Operand<T> var, Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdagradDa
    */
-  public <T extends TType> ApplyAdagradDa<T> applyAdagradDa(Operand<T> var,
+  public <T extends Tensor> ApplyAdagradDa<T> applyAdagradDa(Operand<T> var,
       Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad,
       Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep,
       ApplyAdagradDa.Options... options) {
@@ -251,7 +251,7 @@ public <T extends TType> ApplyAdagradDa<T> applyAdagradDa(Operand<T> var,
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdam
    */
-  public <T extends TType> ApplyAdam<T> applyAdam(Operand<T> var, Operand<T> m, Operand<T> v,
+  public <T extends Tensor> ApplyAdam<T> applyAdam(Operand<T> var, Operand<T> m, Operand<T> v,
       Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1,
       Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, ApplyAdam.Options... options) {
     return ApplyAdam.create(scope, var, m, v, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, options);
@@ -275,8 +275,8 @@ public <T extends TType> ApplyAdam<T> applyAdam(Operand<T> var, Operand<T> m, Op
    * @param options carries optional attributes values
    * @return a new instance of ApplyAddSign
    */
-  public <T extends TType> ApplyAddSign<T> applyAddSign(Operand<T> var, Operand<T> m, Operand<T> lr,
-      Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
+  public <T extends Tensor> ApplyAddSign<T> applyAddSign(Operand<T> var, Operand<T> m,
+      Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
       ApplyAddSign.Options... options) {
     return ApplyAddSign.create(scope, var, m, lr, alpha, signDecay, beta, grad, options);
   }
@@ -316,7 +316,7 @@ public <T extends TType> ApplyAddSign<T> applyAddSign(Operand<T> var, Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ApplyCenteredRmsProp
    */
-  public <T extends TType> ApplyCenteredRmsProp<T> applyCenteredRmsProp(Operand<T> var,
+  public <T extends Tensor> ApplyCenteredRmsProp<T> applyCenteredRmsProp(Operand<T> var,
       Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad,
       ApplyCenteredRmsProp.Options... options) {
@@ -347,7 +347,7 @@ public <T extends TType> ApplyCenteredRmsProp<T> applyCenteredRmsProp(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ApplyFtrl
    */
-  public <T extends TType> ApplyFtrl<T> applyFtrl(Operand<T> var, Operand<T> accum,
+  public <T extends Tensor> ApplyFtrl<T> applyFtrl(Operand<T> var, Operand<T> accum,
       Operand<T> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> l2Shrinkage, Operand<T> lrPower, ApplyFtrl.Options... options) {
     return ApplyFtrl.create(scope, var, accum, linear, grad, lr, l1, l2, l2Shrinkage, lrPower, options);
@@ -363,7 +363,7 @@ public <T extends TType> ApplyFtrl<T> applyFtrl(Operand<T> var, Operand<T> accum
    * @param options carries optional attributes values
    * @return a new instance of ApplyGradientDescent
    */
-  public <T extends TType> ApplyGradientDescent<T> applyGradientDescent(Operand<T> var,
+  public <T extends Tensor> ApplyGradientDescent<T> applyGradientDescent(Operand<T> var,
       Operand<T> alpha, Operand<T> delta, ApplyGradientDescent.Options... options) {
     return ApplyGradientDescent.create(scope, var, alpha, delta, options);
   }
@@ -385,7 +385,7 @@ public <T extends TType> ApplyGradientDescent<T> applyGradientDescent(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ApplyMomentum
    */
-  public <T extends TType> ApplyMomentum<T> applyMomentum(Operand<T> var, Operand<T> accum,
+  public <T extends Tensor> ApplyMomentum<T> applyMomentum(Operand<T> var, Operand<T> accum,
       Operand<T> lr, Operand<T> grad, Operand<T> momentum, ApplyMomentum.Options... options) {
     return ApplyMomentum.create(scope, var, accum, lr, grad, momentum, options);
   }
@@ -408,7 +408,7 @@ public <T extends TType> ApplyMomentum<T> applyMomentum(Operand<T> var, Operand<
    * @param options carries optional attributes values
    * @return a new instance of ApplyPowerSign
    */
-  public <T extends TType> ApplyPowerSign<T> applyPowerSign(Operand<T> var, Operand<T> m,
+  public <T extends Tensor> ApplyPowerSign<T> applyPowerSign(Operand<T> var, Operand<T> m,
       Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
       ApplyPowerSign.Options... options) {
     return ApplyPowerSign.create(scope, var, m, lr, logbase, signDecay, beta, grad, options);
@@ -431,7 +431,7 @@ public <T extends TType> ApplyPowerSign<T> applyPowerSign(Operand<T> var, Operan
    * @param options carries optional attributes values
    * @return a new instance of ApplyProximalAdagrad
    */
-  public <T extends TType> ApplyProximalAdagrad<T> applyProximalAdagrad(Operand<T> var,
+  public <T extends Tensor> ApplyProximalAdagrad<T> applyProximalAdagrad(Operand<T> var,
       Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad,
       ApplyProximalAdagrad.Options... options) {
     return ApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, options);
@@ -452,7 +452,7 @@ public <T extends TType> ApplyProximalAdagrad<T> applyProximalAdagrad(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ApplyProximalGradientDescent
    */
-  public <T extends TType> ApplyProximalGradientDescent<T> applyProximalGradientDescent(
+  public <T extends Tensor> ApplyProximalGradientDescent<T> applyProximalGradientDescent(
       Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta,
       ApplyProximalGradientDescent.Options... options) {
     return ApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, delta, options);
@@ -484,7 +484,7 @@ public <T extends TType> ApplyProximalGradientDescent<T> applyProximalGradientDe
    * @param options carries optional attributes values
    * @return a new instance of ApplyRmsProp
    */
-  public <T extends TType> ApplyRmsProp<T> applyRmsProp(Operand<T> var, Operand<T> ms,
+  public <T extends Tensor> ApplyRmsProp<T> applyRmsProp(Operand<T> var, Operand<T> ms,
       Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon,
       Operand<T> grad, ApplyRmsProp.Options... options) {
     return ApplyRmsProp.create(scope, var, ms, mom, lr, rho, momentum, epsilon, grad, options);
@@ -522,7 +522,7 @@ public <T extends TType> ApplyRmsProp<T> applyRmsProp(Operand<T> var, Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of BatchMatMul
    */
-  public <T extends TType> BatchMatMul<T> batchMatMul(Operand<T> x, Operand<T> y,
+  public <T extends Tensor> BatchMatMul<T> batchMatMul(Operand<T> x, Operand<T> y,
       BatchMatMul.Options... options) {
     return BatchMatMul.create(scope, x, y, options);
   }
@@ -542,7 +542,7 @@ public <T extends TType> BatchMatMul<T> batchMatMul(Operand<T> x, Operand<T> y,
    * @param options carries optional attributes values
    * @return a new instance of ConditionalAccumulator
    */
-  public <T extends TType> ConditionalAccumulator conditionalAccumulator(DataType<T> dtype,
+  public <T extends Tensor> ConditionalAccumulator conditionalAccumulator(DataType<T> dtype,
       Shape shape, ConditionalAccumulator.Options... options) {
     return ConditionalAccumulator.create(scope, dtype, shape, options);
   }
@@ -649,7 +649,7 @@ public NegTrain negTrain(Operand<TFloat32> wIn, Operand<TFloat32> wOut, Operand<
    * @param options carries optional attributes values
    * @return a new instance of PreventGradient
    */
-  public <T extends TType> PreventGradient<T> preventGradient(Operand<T> input,
+  public <T extends Tensor> PreventGradient<T> preventGradient(Operand<T> input,
       PreventGradient.Options... options) {
     return PreventGradient.create(scope, input, options);
   }
@@ -672,7 +672,7 @@ public <T extends TType> PreventGradient<T> preventGradient(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdadelta
    */
-  public <T extends TType> ResourceApplyAdadelta resourceApplyAdadelta(Operand<?> var,
+  public <T extends Tensor> ResourceApplyAdadelta resourceApplyAdadelta(Operand<?> var,
       Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon,
       Operand<T> grad, ResourceApplyAdadelta.Options... options) {
     return ResourceApplyAdadelta.create(scope, var, accum, accumUpdate, lr, rho, epsilon, grad, options);
@@ -692,7 +692,7 @@ public <T extends TType> ResourceApplyAdadelta resourceApplyAdadelta(Operand<?>
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdagradDa
    */
-  public <T extends TType> ResourceApplyAdagradDa resourceApplyAdagradDa(Operand<?> var,
+  public <T extends Tensor> ResourceApplyAdagradDa resourceApplyAdagradDa(Operand<?> var,
       Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad,
       Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep,
       ResourceApplyAdagradDa.Options... options) {
@@ -720,7 +720,7 @@ public <T extends TType> ResourceApplyAdagradDa resourceApplyAdagradDa(Operand<?
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdam
    */
-  public <T extends TType> ResourceApplyAdam resourceApplyAdam(Operand<?> var, Operand<?> m,
+  public <T extends Tensor> ResourceApplyAdam resourceApplyAdam(Operand<?> var, Operand<?> m,
       Operand<?> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1,
       Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, ResourceApplyAdam.Options... options) {
     return ResourceApplyAdam.create(scope, var, m, v, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, options);
@@ -749,10 +749,10 @@ public <T extends TType> ResourceApplyAdam resourceApplyAdam(Operand<?> var, Ope
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdamWithAmsgrad
    */
-  public <T extends TType> ResourceApplyAdamWithAmsgrad resourceApplyAdamWithAmsgrad(Operand<?> var,
-      Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power, Operand<T> beta2Power,
-      Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad,
-      ResourceApplyAdamWithAmsgrad.Options... options) {
+  public <T extends Tensor> ResourceApplyAdamWithAmsgrad resourceApplyAdamWithAmsgrad(
+      Operand<?> var, Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power,
+      Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon,
+      Operand<T> grad, ResourceApplyAdamWithAmsgrad.Options... options) {
     return ResourceApplyAdamWithAmsgrad.create(scope, var, m, v, vhat, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, options);
   }
 
@@ -773,7 +773,7 @@ public <T extends TType> ResourceApplyAdamWithAmsgrad resourceApplyAdamWithAmsgr
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAddSign
    */
-  public <T extends TType> ResourceApplyAddSign resourceApplyAddSign(Operand<?> var, Operand<?> m,
+  public <T extends Tensor> ResourceApplyAddSign resourceApplyAddSign(Operand<?> var, Operand<?> m,
       Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
       ResourceApplyAddSign.Options... options) {
     return ResourceApplyAddSign.create(scope, var, m, lr, alpha, signDecay, beta, grad, options);
@@ -813,8 +813,8 @@ public <T extends TType> ResourceApplyAddSign resourceApplyAddSign(Operand<?> va
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyCenteredRmsProp
    */
-  public <T extends TType> ResourceApplyCenteredRmsProp resourceApplyCenteredRmsProp(Operand<?> var,
-      Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
+  public <T extends Tensor> ResourceApplyCenteredRmsProp resourceApplyCenteredRmsProp(
+      Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad,
       ResourceApplyCenteredRmsProp.Options... options) {
     return ResourceApplyCenteredRmsProp.create(scope, var, mg, ms, mom, lr, rho, momentum, epsilon, grad, options);
@@ -843,7 +843,7 @@ public <T extends TType> ResourceApplyCenteredRmsProp resourceApplyCenteredRmsPr
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyFtrl
    */
-  public <T extends TType> ResourceApplyFtrl resourceApplyFtrl(Operand<?> var, Operand<?> accum,
+  public <T extends Tensor> ResourceApplyFtrl resourceApplyFtrl(Operand<?> var, Operand<?> accum,
       Operand<?> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> l2Shrinkage, Operand<T> lrPower, ResourceApplyFtrl.Options... options) {
     return ResourceApplyFtrl.create(scope, var, accum, linear, grad, lr, l1, l2, l2Shrinkage, lrPower, options);
@@ -858,8 +858,9 @@ public <T extends TType> ResourceApplyFtrl resourceApplyFtrl(Operand<?> var, Ope
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyGradientDescent
    */
-  public <T extends TType> ResourceApplyGradientDescent resourceApplyGradientDescent(Operand<?> var,
-      Operand<T> alpha, Operand<T> delta, ResourceApplyGradientDescent.Options... options) {
+  public <T extends Tensor> ResourceApplyGradientDescent resourceApplyGradientDescent(
+      Operand<?> var, Operand<T> alpha, Operand<T> delta,
+      ResourceApplyGradientDescent.Options... options) {
     return ResourceApplyGradientDescent.create(scope, var, alpha, delta, options);
   }
 
@@ -879,7 +880,7 @@ public <T extends TType> ResourceApplyGradientDescent resourceApplyGradientDesce
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyKerasMomentum
    */
-  public <T extends TType> ResourceApplyKerasMomentum resourceApplyKerasMomentum(Operand<?> var,
+  public <T extends Tensor> ResourceApplyKerasMomentum resourceApplyKerasMomentum(Operand<?> var,
       Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum,
       ResourceApplyKerasMomentum.Options... options) {
     return ResourceApplyKerasMomentum.create(scope, var, accum, lr, grad, momentum, options);
@@ -901,7 +902,7 @@ public <T extends TType> ResourceApplyKerasMomentum resourceApplyKerasMomentum(O
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyMomentum
    */
-  public <T extends TType> ResourceApplyMomentum resourceApplyMomentum(Operand<?> var,
+  public <T extends Tensor> ResourceApplyMomentum resourceApplyMomentum(Operand<?> var,
       Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum,
       ResourceApplyMomentum.Options... options) {
     return ResourceApplyMomentum.create(scope, var, accum, lr, grad, momentum, options);
@@ -924,7 +925,7 @@ public <T extends TType> ResourceApplyMomentum resourceApplyMomentum(Operand<?>
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyPowerSign
    */
-  public <T extends TType> ResourceApplyPowerSign resourceApplyPowerSign(Operand<?> var,
+  public <T extends Tensor> ResourceApplyPowerSign resourceApplyPowerSign(Operand<?> var,
       Operand<?> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta,
       Operand<T> grad, ResourceApplyPowerSign.Options... options) {
     return ResourceApplyPowerSign.create(scope, var, m, lr, logbase, signDecay, beta, grad, options);
@@ -946,9 +947,9 @@ public <T extends TType> ResourceApplyPowerSign resourceApplyPowerSign(Operand<?
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyProximalAdagrad
    */
-  public <T extends TType> ResourceApplyProximalAdagrad resourceApplyProximalAdagrad(Operand<?> var,
-      Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad,
-      ResourceApplyProximalAdagrad.Options... options) {
+  public <T extends Tensor> ResourceApplyProximalAdagrad resourceApplyProximalAdagrad(
+      Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2,
+      Operand<T> grad, ResourceApplyProximalAdagrad.Options... options) {
     return ResourceApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, options);
   }
 
@@ -966,7 +967,7 @@ public <T extends TType> ResourceApplyProximalAdagrad resourceApplyProximalAdagr
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyProximalGradientDescent
    */
-  public <T extends TType> ResourceApplyProximalGradientDescent resourceApplyProximalGradientDescent(
+  public <T extends Tensor> ResourceApplyProximalGradientDescent resourceApplyProximalGradientDescent(
       Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta,
       ResourceApplyProximalGradientDescent.Options... options) {
     return ResourceApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, delta, options);
@@ -997,7 +998,7 @@ public <T extends TType> ResourceApplyProximalGradientDescent resourceApplyProxi
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyRmsProp
    */
-  public <T extends TType> ResourceApplyRmsProp resourceApplyRmsProp(Operand<?> var, Operand<?> ms,
+  public <T extends Tensor> ResourceApplyRmsProp resourceApplyRmsProp(Operand<?> var, Operand<?> ms,
       Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon,
       Operand<T> grad, ResourceApplyRmsProp.Options... options) {
     return ResourceApplyRmsProp.create(scope, var, ms, mom, lr, rho, momentum, epsilon, grad, options);
@@ -1017,7 +1018,7 @@ public <T extends TType> ResourceApplyRmsProp resourceApplyRmsProp(Operand<?> va
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyAdadelta
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyAdadelta resourceSparseApplyAdadelta(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdadelta resourceSparseApplyAdadelta(
       Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho,
       Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyAdadelta.Options... options) {
@@ -1039,7 +1040,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyAdadelta resource
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyAdagrad
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyAdagrad resourceSparseApplyAdagrad(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagrad resourceSparseApplyAdagrad(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyAdagrad.Options... options) {
     return ResourceSparseApplyAdagrad.create(scope, var, accum, lr, grad, indices, options);
@@ -1060,7 +1061,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyAdagrad resourceS
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyAdagradDa
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyAdagradDa resourceSparseApplyAdagradDa(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagradDa resourceSparseApplyAdagradDa(
       Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator,
       Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<TInt64> globalStep, ResourceSparseApplyAdagradDa.Options... options) {
@@ -1100,7 +1101,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyAdagradDa resourc
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyCenteredRmsProp
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyCenteredRmsProp resourceSparseApplyCenteredRmsProp(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyCenteredRmsProp resourceSparseApplyCenteredRmsProp(
       Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyCenteredRmsProp.Options... options) {
@@ -1132,7 +1133,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyCenteredRmsProp r
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyFtrl
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyFtrl resourceSparseApplyFtrl(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyFtrl resourceSparseApplyFtrl(
       Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<U> indices,
       Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower,
       ResourceSparseApplyFtrl.Options... options) {
@@ -1158,7 +1159,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyFtrl resourceSpar
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyKerasMomentum
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyKerasMomentum resourceSparseApplyKerasMomentum(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyKerasMomentum resourceSparseApplyKerasMomentum(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       Operand<T> momentum, ResourceSparseApplyKerasMomentum.Options... options) {
     return ResourceSparseApplyKerasMomentum.create(scope, var, accum, lr, grad, indices, momentum, options);
@@ -1183,7 +1184,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyKerasMomentum res
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyMomentum
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyMomentum resourceSparseApplyMomentum(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyMomentum resourceSparseApplyMomentum(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       Operand<T> momentum, ResourceSparseApplyMomentum.Options... options) {
     return ResourceSparseApplyMomentum.create(scope, var, accum, lr, grad, indices, momentum, options);
@@ -1208,7 +1209,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyMomentum resource
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyProximalAdagrad
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyProximalAdagrad resourceSparseApplyProximalAdagrad(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalAdagrad resourceSparseApplyProximalAdagrad(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> grad, Operand<U> indices, ResourceSparseApplyProximalAdagrad.Options... options) {
     return ResourceSparseApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, indices, options);
@@ -1230,7 +1231,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyProximalAdagrad r
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyProximalGradientDescent
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyProximalGradientDescent resourceSparseApplyProximalGradientDescent(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalGradientDescent resourceSparseApplyProximalGradientDescent(
       Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad,
       Operand<U> indices, ResourceSparseApplyProximalGradientDescent.Options... options) {
     return ResourceSparseApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, grad, indices, options);
@@ -1262,7 +1263,7 @@ public <T extends TType, U extends TNumber> ResourceSparseApplyProximalGradientD
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyRmsProp
    */
-  public <T extends TType, U extends TNumber> ResourceSparseApplyRmsProp resourceSparseApplyRmsProp(
+  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyRmsProp resourceSparseApplyRmsProp(
       Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyRmsProp.Options... options) {
@@ -1320,7 +1321,7 @@ public Restore restore(Operand<TString> prefix, Operand<TString> tensorNames,
    * @param options carries optional attributes values
    * @return a new instance of RestoreSlice
    */
-  public <T extends TType> RestoreSlice<T> restoreSlice(Operand<TString> filePattern,
+  public <T extends Tensor> RestoreSlice<T> restoreSlice(Operand<TString> filePattern,
       Operand<TString> tensorName, Operand<TString> shapeAndSlice, DataType<T> dt,
       RestoreSlice.Options... options) {
     return RestoreSlice.create(scope, filePattern, tensorName, shapeAndSlice, dt, options);
@@ -1430,7 +1431,7 @@ public SdcaShrinkL1 sdcaShrinkL1(Iterable<Operand<TFloat32>> weights, Float l1,
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyAdadelta
    */
-  public <T extends TType, U extends TNumber> SparseApplyAdadelta<T> sparseApplyAdadelta(
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdadelta<T> sparseApplyAdadelta(
       Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho,
       Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       SparseApplyAdadelta.Options... options) {
@@ -1453,7 +1454,7 @@ public <T extends TType, U extends TNumber> SparseApplyAdadelta<T> sparseApplyAd
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyAdagradDa
    */
-  public <T extends TType, U extends TNumber> SparseApplyAdagradDa<T> sparseApplyAdagradDa(
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdagradDa<T> sparseApplyAdagradDa(
       Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator,
       Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<TInt64> globalStep, SparseApplyAdagradDa.Options... options) {
@@ -1494,7 +1495,7 @@ public <T extends TType, U extends TNumber> SparseApplyAdagradDa<T> sparseApplyA
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyCenteredRmsProp
    */
-  public <T extends TType, U extends TNumber> SparseApplyCenteredRmsProp<T> sparseApplyCenteredRmsProp(
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyCenteredRmsProp<T> sparseApplyCenteredRmsProp(
       Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       SparseApplyCenteredRmsProp.Options... options) {
@@ -1527,9 +1528,9 @@ public <T extends TType, U extends TNumber> SparseApplyCenteredRmsProp<T> sparse
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyFtrl
    */
-  public <T extends TType, U extends TNumber> SparseApplyFtrl<T> sparseApplyFtrl(Operand<T> var,
-      Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr,
-      Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower,
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyFtrl<T> sparseApplyFtrl(
+      Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices,
+      Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower,
       SparseApplyFtrl.Options... options) {
     return SparseApplyFtrl.create(scope, var, accum, linear, grad, indices, lr, l1, l2, l2Shrinkage, lrPower, options);
   }
@@ -1554,7 +1555,7 @@ public <T extends TType, U extends TNumber> SparseApplyFtrl<T> sparseApplyFtrl(O
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyMomentum
    */
-  public <T extends TType, U extends TNumber> SparseApplyMomentum<T> sparseApplyMomentum(
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyMomentum<T> sparseApplyMomentum(
       Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       Operand<T> momentum, SparseApplyMomentum.Options... options) {
     return SparseApplyMomentum.create(scope, var, accum, lr, grad, indices, momentum, options);
@@ -1580,7 +1581,7 @@ public <T extends TType, U extends TNumber> SparseApplyMomentum<T> sparseApplyMo
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyProximalAdagrad
    */
-  public <T extends TType, U extends TNumber> SparseApplyProximalAdagrad<T> sparseApplyProximalAdagrad(
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalAdagrad<T> sparseApplyProximalAdagrad(
       Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> grad, Operand<U> indices, SparseApplyProximalAdagrad.Options... options) {
     return SparseApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, indices, options);
@@ -1603,7 +1604,7 @@ public <T extends TType, U extends TNumber> SparseApplyProximalAdagrad<T> sparse
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyProximalGradientDescent
    */
-  public <T extends TType, U extends TNumber> SparseApplyProximalGradientDescent<T> sparseApplyProximalGradientDescent(
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalGradientDescent<T> sparseApplyProximalGradientDescent(
       Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad,
       Operand<U> indices, SparseApplyProximalGradientDescent.Options... options) {
     return SparseApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, grad, indices, options);
@@ -1636,7 +1637,7 @@ public <T extends TType, U extends TNumber> SparseApplyProximalGradientDescent<T
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyRmsProp
    */
-  public <T extends TType, U extends TNumber> SparseApplyRmsProp<T> sparseApplyRmsProp(
+  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyRmsProp<T> sparseApplyRmsProp(
       Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       SparseApplyRmsProp.Options... options) {
@@ -1655,7 +1656,7 @@ public <T extends TType, U extends TNumber> SparseApplyRmsProp<T> sparseApplyRms
    * @param multiples
    * @return a new instance of TileGrad
    */
-  public <T extends TType> TileGrad<T> tileGrad(Operand<T> input, Operand<TInt32> multiples) {
+  public <T extends Tensor> TileGrad<T> tileGrad(Operand<T> input, Operand<TInt32> multiples) {
     return TileGrad.create(scope, input, multiples);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java
index 535972d4883..01d4ffa1ba7 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java
@@ -19,6 +19,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.xla.BroadcastHelper;
 import org.tensorflow.op.xla.ClusterOutput;
@@ -39,7 +40,6 @@
 import org.tensorflow.op.xla.Sort;
 import org.tensorflow.op.xla.Svd;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code xla} operations as {@link Op Op}s
@@ -66,8 +66,8 @@ public final class XlaOps {
    * @param broadcastDims an XLA-style broadcast dimension specification
    * @return a new instance of BroadcastHelper
    */
-  public <T extends TType, U extends TNumber> BroadcastHelper<T> broadcastHelper(Operand<T> lhs,
-      Operand<T> rhs, Operand<U> broadcastDims) {
+  public <T extends Tensor, U extends Tensor & TNumber> BroadcastHelper<T> broadcastHelper(
+      Operand<T> lhs, Operand<T> rhs, Operand<U> broadcastDims) {
     return BroadcastHelper.create(scope, lhs, rhs, broadcastDims);
   }
 
@@ -78,7 +78,7 @@ public <T extends TType, U extends TNumber> BroadcastHelper<T> broadcastHelper(O
    * @param input
    * @return a new instance of ClusterOutput
    */
-  public <T extends TType> ClusterOutput<T> clusterOutput(Operand<T> input) {
+  public <T extends Tensor> ClusterOutput<T> clusterOutput(Operand<T> input) {
     return ClusterOutput.create(scope, input);
   }
 
@@ -100,7 +100,7 @@ public <T extends TType> ClusterOutput<T> clusterOutput(Operand<T> input) {
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
    * @return a new instance of Conv
    */
-  public <T extends TType, U extends TNumber> Conv<T> conv(Operand<T> lhs, Operand<T> rhs,
+  public <T extends Tensor, U extends Tensor & TNumber> Conv<T> conv(Operand<T> lhs, Operand<T> rhs,
       Operand<U> windowStrides, Operand<U> padding, Operand<U> lhsDilation, Operand<U> rhsDilation,
       Operand<U> featureGroupCount, String dimensionNumbers, String precisionConfig) {
     return Conv.create(scope, lhs, rhs, windowStrides, padding, lhsDilation, rhsDilation, featureGroupCount, dimensionNumbers, precisionConfig);
@@ -137,7 +137,7 @@ public Dequantize dequantize(Operand<?> input, Float minRange, Float maxRange, S
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
    * @return a new instance of Dot
    */
-  public <T extends TType> Dot<T> dot(Operand<T> lhs, Operand<T> rhs, String dimensionNumbers,
+  public <T extends Tensor> Dot<T> dot(Operand<T> lhs, Operand<T> rhs, String dimensionNumbers,
       String precisionConfig) {
     return Dot.create(scope, lhs, rhs, dimensionNumbers, precisionConfig);
   }
@@ -163,8 +163,8 @@ public <T extends TType> Dot<T> dot(Operand<T> lhs, Operand<T> rhs, String dimen
    * @param sizeIndices
    * @return a new instance of DynamicSlice
    */
-  public <T extends TType, U extends TNumber> DynamicSlice<T> dynamicSlice(Operand<T> input,
-      Operand<U> startIndices, Operand<U> sizeIndices) {
+  public <T extends Tensor, U extends Tensor & TNumber> DynamicSlice<T> dynamicSlice(
+      Operand<T> input, Operand<U> startIndices, Operand<U> sizeIndices) {
     return DynamicSlice.create(scope, input, startIndices, sizeIndices);
   }
 
@@ -188,7 +188,7 @@ public <T extends TType, U extends TNumber> DynamicSlice<T> dynamicSlice(Operand
    *  `input`.
    * @return a new instance of DynamicUpdateSlice
    */
-  public <T extends TType, U extends TNumber> DynamicUpdateSlice<T> dynamicUpdateSlice(
+  public <T extends Tensor, U extends Tensor & TNumber> DynamicUpdateSlice<T> dynamicUpdateSlice(
       Operand<T> input, Operand<T> update, Operand<U> indices) {
     return DynamicUpdateSlice.create(scope, input, update, indices);
   }
@@ -205,7 +205,7 @@ public <T extends TType, U extends TNumber> DynamicUpdateSlice<T> dynamicUpdateS
    * @param equation
    * @return a new instance of Einsum
    */
-  public <T extends TType> Einsum<T> einsum(Operand<T> a, Operand<T> b, String equation) {
+  public <T extends Tensor> Einsum<T> einsum(Operand<T> a, Operand<T> b, String equation) {
     return Einsum.create(scope, a, b, equation);
   }
 
@@ -222,7 +222,7 @@ public <T extends TType> Einsum<T> einsum(Operand<T> a, Operand<T> b, String equ
    * @param indicesAreSorted Boolean indicating if the indices are sorted.
    * @return a new instance of Gather
    */
-  public <T extends TType, U extends TNumber> Gather<T> gather(Operand<T> operand,
+  public <T extends Tensor, U extends Tensor & TNumber> Gather<T> gather(Operand<T> operand,
       Operand<U> startIndices, Operand<U> sliceSizes, String dimensionNumbers,
       Boolean indicesAreSorted) {
     return Gather.create(scope, operand, startIndices, sliceSizes, dimensionNumbers, indicesAreSorted);
@@ -242,8 +242,8 @@ public <T extends TType, U extends TNumber> Gather<T> gather(Operand<T> operand,
    * @param values A `Tensor` of type V.
    * @return a new instance of KeyValueSort
    */
-  public <T extends TNumber, U extends TType> KeyValueSort<T, U> keyValueSort(Operand<T> keys,
-      Operand<U> values) {
+  public <T extends Tensor & TNumber, U extends Tensor> KeyValueSort<T, U> keyValueSort(
+      Operand<T> keys, Operand<U> values) {
     return KeyValueSort.create(scope, keys, values);
   }
 
@@ -261,8 +261,9 @@ public <T extends TNumber, U extends TType> KeyValueSort<T, U> keyValueSort(Oper
    * @param paddingInterior the padding to apply between each input element.
    * @return a new instance of Pad
    */
-  public <T extends TType, U extends TNumber> Pad<T> pad(Operand<T> input, Operand<T> paddingValue,
-      Operand<U> paddingLow, Operand<U> paddingHigh, Operand<U> paddingInterior) {
+  public <T extends Tensor, U extends Tensor & TNumber> Pad<T> pad(Operand<T> input,
+      Operand<T> paddingValue, Operand<U> paddingLow, Operand<U> paddingHigh,
+      Operand<U> paddingInterior) {
     return Pad.create(scope, input, paddingValue, paddingLow, paddingHigh, paddingInterior);
   }
 
@@ -278,7 +279,7 @@ public <T extends TType, U extends TNumber> Pad<T> pad(Operand<T> input, Operand
    * @param shape The shape of the tensor.
    * @return a new instance of Recv
    */
-  public <T extends TType> Recv<T> recv(DataType<T> dtype, String tensorName, Shape shape) {
+  public <T extends Tensor> Recv<T> recv(DataType<T> dtype, String tensorName, Shape shape) {
     return Recv.create(scope, dtype, tensorName, shape);
   }
 
@@ -311,7 +312,7 @@ public ReplicaId replicaId() {
    * @param epsilon the tolerance ratio.
    * @return a new instance of SelfAdjointEig
    */
-  public <T extends TType> SelfAdjointEig<T> selfAdjointEig(Operand<T> a, Boolean lower,
+  public <T extends Tensor> SelfAdjointEig<T> selfAdjointEig(Operand<T> a, Boolean lower,
       Long maxIter, Float epsilon) {
     return SelfAdjointEig.create(scope, a, lower, maxIter, epsilon);
   }
@@ -326,7 +327,7 @@ public <T extends TType> SelfAdjointEig<T> selfAdjointEig(Operand<T> a, Boolean
    * @param tensorName A string key that identifies the channel.
    * @return a new instance of Send
    */
-  public <T extends TType> Send send(Operand<T> tensor, String tensorName) {
+  public <T extends Tensor> Send send(Operand<T> tensor, String tensorName) {
     return Send.create(scope, tensor, tensorName);
   }
 
@@ -337,7 +338,7 @@ public <T extends TType> Send send(Operand<T> tensor, String tensorName) {
    * @param input
    * @return a new instance of Sharding
    */
-  public <T extends TType> Sharding<T> sharding(Operand<T> input) {
+  public <T extends Tensor> Sharding<T> sharding(Operand<T> input) {
     return Sharding.create(scope, input);
   }
 
@@ -353,7 +354,7 @@ public <T extends TType> Sharding<T> sharding(Operand<T> input) {
    * @param input A `Tensor` of type T.
    * @return a new instance of Sort
    */
-  public <T extends TType> Sort<T> sort(Operand<T> input) {
+  public <T extends Tensor> Sort<T> sort(Operand<T> input) {
     return Sort.create(scope, input);
   }
 
@@ -375,7 +376,7 @@ public <T extends TType> Sort<T> sort(Operand<T> input) {
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
    * @return a new instance of Svd
    */
-  public <T extends TType> Svd<T> svd(Operand<T> a, Long maxIter, Float epsilon,
+  public <T extends Tensor> Svd<T> svd(Operand<T> a, Long maxIter, Float epsilon,
       String precisionConfig) {
     return Svd.create(scope, a, maxIter, epsilon, precisionConfig);
   }
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 70318891190..b77f54e56ea 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Elementwise computes the bitwise AND of `x` and `y`.
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseAnd<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BitwiseAnd<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BitwiseAnd operation.
@@ -65,7 +65,7 @@ public final class BitwiseAnd<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of BitwiseAnd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BitwiseAnd<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> BitwiseAnd<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("BitwiseAnd", scope.makeOpName("BitwiseAnd"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 4d882a6c202..ddcc206c9da 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Elementwise computes the bitwise OR of `x` and `y`.
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseOr<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BitwiseOr<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BitwiseOr operation.
@@ -65,7 +65,7 @@ public final class BitwiseOr<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of BitwiseOr
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BitwiseOr<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> BitwiseOr<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("BitwiseOr", scope.makeOpName("BitwiseOr"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 597ae15fb90..272aee6ece8 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Elementwise computes the bitwise XOR of `x` and `y`.
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseXor<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BitwiseXor<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BitwiseXor operation.
@@ -65,7 +65,7 @@ public final class BitwiseXor<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of BitwiseXor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BitwiseXor<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> BitwiseXor<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("BitwiseXor", scope.makeOpName("BitwiseXor"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 6cbacade24d..7c680b4bfdc 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.
@@ -75,7 +75,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "bitwise")
-public final class Invert<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Invert<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Invert operation.
@@ -85,7 +85,7 @@ public final class Invert<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Invert
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Invert<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Invert<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Invert", scope.makeOpName("Invert"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 bddf9269c42..b0b9d5bf9ec 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Elementwise computes the bitwise left-shift of `x` and `y`.
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class LeftShift<T extends TNumber> extends RawOp implements Operand<T> {
+public final class LeftShift<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new LeftShift operation.
@@ -76,7 +76,7 @@ public final class LeftShift<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of LeftShift
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LeftShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> LeftShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("LeftShift", scope.makeOpName("LeftShift"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 92487345d8c..d9d71249c17 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Elementwise computes the bitwise right-shift of `x` and `y`.
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class RightShift<T extends TNumber> extends RawOp implements Operand<T> {
+public final class RightShift<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RightShift operation.
@@ -79,7 +79,7 @@ public final class RightShift<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of RightShift
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> RightShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> RightShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("RightShift", scope.makeOpName("RightShift"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 40125fa7856..36802bca597 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Mutually reduces multiple tensors of identical type and shape.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AllReduce<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AllReduce<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.AllReduce}
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of AllReduce
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AllReduce<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, String mergeOp, String finalOp, List<Long> subdivOffsets, Options... options) {
+  public static <T extends Tensor & TNumber> AllReduce<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, String mergeOp, String finalOp, List<Long> subdivOffsets, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveReduce", scope.makeOpName("AllReduce"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c754a3d9dea..02c3aaed8f5 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Receives a tensor value broadcast from another device.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class BroadcastRecv<T extends TType> extends RawOp implements Operand<T> {
+public final class BroadcastRecv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.BroadcastRecv}
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of BroadcastRecv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BroadcastRecv<T> create(Scope scope, DataType<T> T, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
+  public static <T extends Tensor> BroadcastRecv<T> create(Scope scope, DataType<T> T, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveBcastRecv", scope.makeOpName("BroadcastRecv"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("T", T);
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 72f721a9fa3..4e6b36d4d9a 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Broadcasts a tensor value to one or more other devices.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class BroadcastSend<T extends TType> extends RawOp implements Operand<T> {
+public final class BroadcastSend<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.BroadcastSend}
@@ -67,7 +67,7 @@ private Options() {
    * @return a new instance of BroadcastSend
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BroadcastSend<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
+  public static <T extends Tensor> BroadcastSend<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveBcastSend", scope.makeOpName("BroadcastSend"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 2c92e6934cc..e77f4a0651b 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the "logical and" of elements across dimensions of a tensor.
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of All
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> All create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends Tensor & TNumber> All create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("All", scope.makeOpName("All"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 c30305b2207..5acc0247db6 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the "logical or" of elements across dimensions of a tensor.
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of Any
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Any create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends Tensor & TNumber> Any create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Any", scope.makeOpName("Any"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 c0319759f33..1c10f9fc35e 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update 'ref' by assigning 'value' to it.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class Assign<T extends TType> extends RawOp implements Operand<T> {
+public final class Assign<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Assign}
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of Assign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Assign<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
+  public static <T extends Tensor> Assign<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Assign", scope.makeOpName("Assign"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(value.asOutput());
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 9208756aa95..61a3a287abd 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update 'ref' by adding 'value' to it.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class AssignAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class AssignAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.AssignAdd}
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of AssignAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AssignAdd<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
+  public static <T extends Tensor> AssignAdd<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignAdd", scope.makeOpName("AssignAdd"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(value.asOutput());
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 3725c318637..cf3f4c9560c 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds a value to the current value of a variable.
@@ -44,7 +44,7 @@ public final class AssignAddVariableOp extends RawOp {
    * @return a new instance of AssignAddVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AssignAddVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
+  public static <T extends Tensor> AssignAddVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignAddVariableOp", scope.makeOpName("AssignAddVariableOp"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(value.asOutput());
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 13506b03543..defe21e80a6 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update 'ref' by subtracting 'value' from it.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class AssignSub<T extends TType> extends RawOp implements Operand<T> {
+public final class AssignSub<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.AssignSub}
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of AssignSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AssignSub<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
+  public static <T extends Tensor> AssignSub<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignSub", scope.makeOpName("AssignSub"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(value.asOutput());
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 c47fc330702..3168e4924ea 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts a value from the current value of a variable.
@@ -44,7 +44,7 @@ public final class AssignSubVariableOp extends RawOp {
    * @return a new instance of AssignSubVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AssignSubVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
+  public static <T extends Tensor> AssignSubVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignSubVariableOp", scope.makeOpName("AssignSubVariableOp"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(value.asOutput());
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 bdd89c0204d..0a959b0a191 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Assigns a new value to a variable.
@@ -44,7 +44,7 @@ public final class AssignVariableOp extends RawOp {
    * @return a new instance of AssignVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AssignVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
+  public static <T extends Tensor> AssignVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignVariableOp", scope.makeOpName("AssignVariableOp"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(value.asOutput());
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 8e16fe1df11..8fa2db8d22b 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * For each key, assigns the respective value to the specified component.
@@ -50,7 +50,7 @@ public final class BarrierInsertMany extends RawOp {
    * @return a new instance of BarrierInsertMany
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BarrierInsertMany create(Scope scope, Operand<TString> handle, Operand<TString> keys, Operand<T> values, Long componentIndex) {
+  public static <T extends Tensor> BarrierInsertMany create(Scope scope, Operand<TString> handle, Operand<TString> keys, Operand<T> values, Long componentIndex) {
     OperationBuilder opBuilder = scope.env().opBuilder("BarrierInsertMany", scope.makeOpName("BarrierInsertMany"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(keys.asOutput());
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 3d1fc8af44e..1dabeb6aa03 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * BatchToSpace for 4-D tensors of type T.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BatchToSpace<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchToSpace<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchToSpace operation.
@@ -61,7 +61,7 @@ public final class BatchToSpace<T extends TType> extends RawOp implements Operan
    * @return a new instance of BatchToSpace
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> BatchToSpace<T> create(Scope scope, Operand<T> input, Operand<U> crops, Long blockSize) {
+  public static <T extends Tensor, U extends Tensor & TNumber> BatchToSpace<T> create(Scope scope, Operand<T> input, Operand<U> crops, Long blockSize) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchToSpace", scope.makeOpName("BatchToSpace"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(crops.asOutput());
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 8c2a3d9b703..97cba096529 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * BatchToSpace for N-D tensors of type T.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BatchToSpaceNd<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchToSpaceNd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchToSpaceNd operation.
@@ -148,7 +148,7 @@ public final class BatchToSpaceNd<T extends TType> extends RawOp implements Oper
    * @return a new instance of BatchToSpaceNd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber, V extends TNumber> BatchToSpaceNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> crops) {
+  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> BatchToSpaceNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> crops) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchToSpaceND", scope.makeOpName("BatchToSpaceNd"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(blockShape.asOutput());
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 fa7777e0d98..e7c8dee1d75 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Bitcasts a tensor from one type to another without copying data.
@@ -85,7 +85,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Bitcast<U extends TType> extends RawOp implements Operand<U> {
+public final class Bitcast<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Bitcast operation.
@@ -96,7 +96,7 @@ public final class Bitcast<U extends TType> extends RawOp implements Operand<U>
    * @return a new instance of Bitcast
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> Bitcast<U> create(Scope scope, Operand<T> input, DataType<U> type) {
+  public static <U extends Tensor, T extends Tensor> Bitcast<U> create(Scope scope, Operand<T> input, DataType<U> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("Bitcast", scope.makeOpName("Bitcast"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 88758189167..5d50fb142e0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return the shape of s0 op s1 with broadcast.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code r0()} output
  */
 @Operator
-public final class BroadcastDynamicShape<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BroadcastDynamicShape<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BroadcastDynamicShape operation.
@@ -48,7 +48,7 @@ public final class BroadcastDynamicShape<T extends TNumber> extends RawOp implem
    * @return a new instance of BroadcastDynamicShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BroadcastDynamicShape<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
+  public static <T extends Tensor & TNumber> BroadcastDynamicShape<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
     OperationBuilder opBuilder = scope.env().opBuilder("BroadcastArgs", scope.makeOpName("BroadcastDynamicShape"));
     opBuilder.addInput(s0.asOutput());
     opBuilder.addInput(s1.asOutput());
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 309cfef9430..3c14cc20dcd 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return the reduction indices for computing gradients of s0 op s1 with broadcast.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code r0()} output
  */
-public final class BroadcastGradientArgs<T extends TNumber> extends RawOp {
+public final class BroadcastGradientArgs<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BroadcastGradientArgs operation.
@@ -46,7 +46,7 @@ public final class BroadcastGradientArgs<T extends TNumber> extends RawOp {
    * @return a new instance of BroadcastGradientArgs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BroadcastGradientArgs<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
+  public static <T extends Tensor & TNumber> BroadcastGradientArgs<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
     OperationBuilder opBuilder = scope.env().opBuilder("BroadcastGradientArgs", scope.makeOpName("BroadcastGradientArgs"));
     opBuilder.addInput(s0.asOutput());
     opBuilder.addInput(s1.asOutput());
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 e4c1b80764f..27480128b6f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Broadcast an array for a compatible shape.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BroadcastTo<T extends TType> extends RawOp implements Operand<T> {
+public final class BroadcastTo<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BroadcastTo operation.
@@ -64,7 +64,7 @@ public final class BroadcastTo<T extends TType> extends RawOp implements Operand
    * @return a new instance of BroadcastTo
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> BroadcastTo<T> create(Scope scope, Operand<T> input, Operand<U> shape) {
+  public static <T extends Tensor, U extends Tensor & TNumber> BroadcastTo<T> create(Scope scope, Operand<T> input, Operand<U> shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("BroadcastTo", scope.makeOpName("BroadcastTo"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(shape.asOutput());
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 f7f32115de1..c310c43150a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Bucketizes 'input' based on 'boundaries'.
@@ -56,7 +56,7 @@ public final class Bucketize extends RawOp implements Operand<TInt32> {
    * @return a new instance of Bucketize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Bucketize create(Scope scope, Operand<T> input, List<Float> boundaries) {
+  public static <T extends Tensor & TNumber> Bucketize create(Scope scope, Operand<T> input, List<Float> boundaries) {
     OperationBuilder opBuilder = scope.env().opBuilder("Bucketize", scope.makeOpName("Bucketize"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1c33f21ba98..d146af9ebce 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Clips tensor values to a specified min and max.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ClipByValue<T extends TType> extends RawOp implements Operand<T> {
+public final class ClipByValue<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ClipByValue operation.
@@ -52,7 +52,7 @@ public final class ClipByValue<T extends TType> extends RawOp implements Operand
    * @return a new instance of ClipByValue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ClipByValue<T> create(Scope scope, Operand<T> t, Operand<T> clipValueMin, Operand<T> clipValueMax) {
+  public static <T extends Tensor> ClipByValue<T> create(Scope scope, Operand<T> t, Operand<T> clipValueMin, Operand<T> clipValueMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("ClipByValue", scope.makeOpName("ClipByValue"));
     opBuilder.addInput(t.asOutput());
     opBuilder.addInput(clipValueMin.asOutput());
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 da4f82ad2a2..de776adcd3a 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,20 +21,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Mutually accumulates multiple tensors of identical type and shape.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CollectiveGather<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CollectiveGather<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.CollectiveGather}
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of CollectiveGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CollectiveGather<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
+  public static <T extends Tensor & TNumber> CollectiveGather<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveGather", scope.makeOpName("CollectiveGather"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 eb62cb86bf5..f48206bf292 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates tensors along one dimension.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Concat<T extends TType> extends RawOp implements Operand<T> {
+public final class Concat<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Concat operation.
@@ -48,7 +48,7 @@ public final class Concat<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Concat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Concat<T> create(Scope scope, Iterable<Operand<T>> values, Operand<U> axis) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Concat<T> create(Scope scope, Iterable<Operand<T>> values, Operand<U> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConcatV2", scope.makeOpName("Concat"));
     opBuilder.addInputList(Operands.asOutputs(values));
     opBuilder.addInput(axis.asOutput());
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 6ca879bf1b9..103d2239eca 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Copy a tensor from CPU-to-CPU or GPU-to-GPU.
@@ -42,7 +42,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Copy<T extends TType> extends RawOp implements Operand<T> {
+public final class Copy<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Copy}
@@ -85,7 +85,7 @@ private Options() {
    * @return a new instance of Copy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Copy<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> Copy<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Copy", scope.makeOpName("Copy"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 b57961ead25..f51be2057ac 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Copy a tensor to host.
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CopyHost<T extends TType> extends RawOp implements Operand<T> {
+public final class CopyHost<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.CopyHost}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of CopyHost
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> CopyHost<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> CopyHost<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CopyHost", scope.makeOpName("CopyHost"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 84dfbc90633..0cc4201156a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Increments 'ref' until it reaches 'limit'.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class CountUpTo<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CountUpTo<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CountUpTo operation.
@@ -46,7 +46,7 @@ public final class CountUpTo<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of CountUpTo
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CountUpTo<T> create(Scope scope, Operand<T> ref, Long limit) {
+  public static <T extends Tensor & TNumber> CountUpTo<T> create(Scope scope, Operand<T> ref, Long limit) {
     OperationBuilder opBuilder = scope.env().opBuilder("CountUpTo", scope.makeOpName("CountUpTo"));
     opBuilder.addInput(ref.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 0abe365a8a9..e613de3d291 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Makes a copy of `x`.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class DeepCopy<T extends TType> extends RawOp implements Operand<T> {
+public final class DeepCopy<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DeepCopy operation.
@@ -43,7 +43,7 @@ public final class DeepCopy<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of DeepCopy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DeepCopy<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> DeepCopy<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeepCopy", scope.makeOpName("DeepCopy"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 65fa9c62e4a..361184cb79c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Destroys the temporary variable and returns its final value.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class DestroyTemporaryVariable<T extends TType> extends RawOp implements Operand<T> {
+public final class DestroyTemporaryVariable<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DestroyTemporaryVariable operation.
@@ -53,7 +53,7 @@ public final class DestroyTemporaryVariable<T extends TType> extends RawOp imple
    * @return a new instance of DestroyTemporaryVariable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DestroyTemporaryVariable<T> create(Scope scope, Operand<T> ref, String varName) {
+  public static <T extends Tensor> DestroyTemporaryVariable<T> create(Scope scope, Operand<T> ref, String varName) {
     OperationBuilder opBuilder = scope.env().opBuilder("DestroyTemporaryVariable", scope.makeOpName("DestroyTemporaryVariable"));
     opBuilder.addInput(ref.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java
index c5a6187d1ed..14d987e2879 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java
@@ -21,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class DummyMemoryCache extends RawOp implements Operand<TType> {
+public final class DummyMemoryCache extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new DummyMemoryCache operation.
@@ -52,8 +52,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 48dd3b54f8e..f749065992e 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,12 +24,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Partitions `data` into `num_partitions` tensors using indices from `partitions`.
@@ -71,7 +71,7 @@
  * @param <T> data type for {@code outputs()} output
  */
 @Operator
-public final class DynamicPartition<T extends TType> extends RawOp implements Iterable<Operand<T>> {
+public final class DynamicPartition<T extends Tensor> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new DynamicPartition operation.
@@ -83,7 +83,7 @@ public final class DynamicPartition<T extends TType> extends RawOp implements It
    * @return a new instance of DynamicPartition
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DynamicPartition<T> create(Scope scope, Operand<T> data, Operand<TInt32> partitions, Long numPartitions) {
+  public static <T extends Tensor> DynamicPartition<T> create(Scope scope, Operand<T> data, Operand<TInt32> partitions, Long numPartitions) {
     OperationBuilder opBuilder = scope.env().opBuilder("DynamicPartition", scope.makeOpName("DynamicPartition"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(partitions.asOutput());
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 ba41dcf77f8..2fd2206f798 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Interleave the values from the `data` tensors into a single tensor.
@@ -90,7 +90,7 @@
  * @param <T> data type for {@code merged()} output
  */
 @Operator
-public final class DynamicStitch<T extends TType> extends RawOp implements Operand<T> {
+public final class DynamicStitch<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DynamicStitch operation.
@@ -101,7 +101,7 @@ public final class DynamicStitch<T extends TType> extends RawOp implements Opera
    * @return a new instance of DynamicStitch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
+  public static <T extends Tensor> DynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("DynamicStitch", scope.makeOpName("DynamicStitch"));
     opBuilder.addInputList(Operands.asOutputs(indices));
     opBuilder.addInputList(Operands.asOutputs(data));
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 7c0a35798d5..6c799f18e0b 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the (possibly normalized) Levenshtein Edit Distance.
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of EditDistance
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> EditDistance create(Scope scope, Operand<TInt64> hypothesisIndices, Operand<T> hypothesisValues, Operand<TInt64> hypothesisShape, Operand<TInt64> truthIndices, Operand<T> truthValues, Operand<TInt64> truthShape, Options... options) {
+  public static <T extends Tensor> EditDistance create(Scope scope, Operand<TInt64> hypothesisIndices, Operand<T> hypothesisValues, Operand<TInt64> hypothesisShape, Operand<TInt64> truthIndices, Operand<T> truthValues, Operand<TInt64> truthShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EditDistance", scope.makeOpName("EditDistance"));
     opBuilder.addInput(hypothesisIndices.asOutput());
     opBuilder.addInput(hypothesisValues.asOutput());
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 0e39ea25f92..ce7d5566cca 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a tensor with the given shape.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Empty<T extends TType> extends RawOp implements Operand<T> {
+public final class Empty<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Empty}
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of Empty
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Empty<T> create(Scope scope, Operand<TInt32> shape, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> Empty<T> create(Scope scope, Operand<TInt32> shape, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Empty", scope.makeOpName("Empty"));
     opBuilder.addInput(shape.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 e91ebafbb03..9421ee881c1 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates and returns an empty tensor list.
@@ -41,7 +41,7 @@
  * element_shape: a shape compatible with that of elements in the list.
  */
 @Operator
-public final class EmptyTensorList extends RawOp implements Operand<TType> {
+public final class EmptyTensorList extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new EmptyTensorList operation.
@@ -53,7 +53,7 @@ public final class EmptyTensorList extends RawOp implements Operand<TType> {
    * @return a new instance of EmptyTensorList
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> EmptyTensorList create(Scope scope, Operand<T> elementShape, Operand<TInt32> maxNumElements, DataType<U> elementDtype) {
+  public static <T extends Tensor & TNumber, U extends Tensor> EmptyTensorList create(Scope scope, Operand<T> elementShape, Operand<TInt32> maxNumElements, DataType<U> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("EmptyTensorList", scope.makeOpName("EmptyTensorList"));
     opBuilder.addInput(elementShape.asOutput());
     opBuilder.addInput(maxNumElements.asOutput());
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 3b8a8790afa..8728cfb6601 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Ensures that the tensor's shape matches the expected shape.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class EnsureShape<T extends TType> extends RawOp implements Operand<T> {
+public final class EnsureShape<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new EnsureShape operation.
@@ -48,7 +48,7 @@ public final class EnsureShape<T extends TType> extends RawOp implements Operand
    * @return a new instance of EnsureShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> EnsureShape<T> create(Scope scope, Operand<T> input, Shape shape) {
+  public static <T extends Tensor> EnsureShape<T> create(Scope scope, Operand<T> input, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("EnsureShape", scope.makeOpName("EnsureShape"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 d6802061959..6a658622e76 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates or finds a child frame, and makes `data` available to the child frame.
@@ -38,7 +38,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Enter<T extends TType> extends RawOp implements Operand<T> {
+public final class Enter<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Enter}
@@ -78,7 +78,7 @@ private Options() {
    * @return a new instance of Enter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Enter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
+  public static <T extends Tensor> Enter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Enter", scope.makeOpName("Enter"));
     opBuilder.addInput(data.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 879225e5dbc..c23aa50ea5c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Exits the current frame to its parent frame.
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Exit<T extends TType> extends RawOp implements Operand<T> {
+public final class Exit<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Exit operation.
@@ -44,7 +44,7 @@ public final class Exit<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Exit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Exit<T> create(Scope scope, Operand<T> data) {
+  public static <T extends Tensor> Exit<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("Exit", scope.makeOpName("Exit"));
     opBuilder.addInput(data.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 12cb36b98dc..85a271d08bd 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Inserts a dimension of 1 into a tensor's shape.
@@ -63,7 +63,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ExpandDims<T extends TType> extends RawOp implements Operand<T> {
+public final class ExpandDims<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExpandDims operation.
@@ -76,7 +76,7 @@ public final class ExpandDims<T extends TType> extends RawOp implements Operand<
    * @return a new instance of ExpandDims
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ExpandDims<T> create(Scope scope, Operand<T> input, Operand<U> axis) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ExpandDims<T> create(Scope scope, Operand<T> input, Operand<U> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExpandDims", scope.makeOpName("ExpandDims"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 6816275860b..d5d4b616149 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Extract `patches` from `input` and put them in the "depth" output dimension. 3D extension of `extract_image_patches`.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code patches()} output
  */
 @Operator
-public final class ExtractVolumePatches<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ExtractVolumePatches<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExtractVolumePatches operation.
@@ -56,7 +56,7 @@ public final class ExtractVolumePatches<T extends TNumber> extends RawOp impleme
    * @return a new instance of ExtractVolumePatches
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ExtractVolumePatches<T> create(Scope scope, Operand<T> input, List<Long> ksizes, List<Long> strides, String padding) {
+  public static <T extends Tensor & TNumber> ExtractVolumePatches<T> create(Scope scope, Operand<T> input, List<Long> ksizes, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExtractVolumePatches", scope.makeOpName("ExtractVolumePatches"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 adbcc23f363..b42deb2ebd9 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a tensor filled with a scalar value.
@@ -57,7 +57,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Fill<U extends TType> extends RawOp implements Operand<U> {
+public final class Fill<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Fill operation.
@@ -72,7 +72,7 @@ public final class Fill<U extends TType> extends RawOp implements Operand<U> {
    * @return a new instance of Fill
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> Fill<U> create(Scope scope, Operand<T> dims, Operand<U> value) {
+  public static <U extends Tensor, T extends Tensor & TNumber> Fill<U> create(Scope scope, Operand<T> dims, Operand<U> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("Fill", scope.makeOpName("Fill"));
     opBuilder.addInput(dims.asOutput());
     opBuilder.addInput(value.asOutput());
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 4aca6b0201e..4780506ec70 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.TUint8;
-import org.tensorflow.types.family.TType;
 
 /**
  * Generates fingerprint values.
@@ -74,7 +74,7 @@ public final class Fingerprint extends RawOp implements Operand<TUint8> {
    * @return a new instance of Fingerprint
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Fingerprint create(Scope scope, Operand<T> data, Operand<TString> method) {
+  public static <T extends Tensor> Fingerprint create(Scope scope, Operand<T> data, Operand<TString> method) {
     OperationBuilder opBuilder = scope.env().opBuilder("Fingerprint", scope.makeOpName("Fingerprint"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(method.asOutput());
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 8eaec57f813..fb8a6a8adc0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gather slices from `params` axis `axis` according to `indices`.
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Gather<T extends TType> extends RawOp implements Operand<T> {
+public final class Gather<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Gather}
@@ -94,7 +94,7 @@ private Options() {
    * @return a new instance of Gather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber, V extends TNumber> Gather<T> create(Scope scope, Operand<T> params, Operand<U> indices, Operand<V> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Gather<T> create(Scope scope, Operand<T> params, Operand<U> indices, Operand<V> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("GatherV2", scope.makeOpName("Gather"));
     opBuilder.addInput(params.asOutput());
     opBuilder.addInput(indices.asOutput());
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 917db87705f..eb51695d54f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gather slices from `params` into a Tensor with shape specified by `indices`.
@@ -127,7 +127,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class GatherNd<T extends TType> extends RawOp implements Operand<T> {
+public final class GatherNd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new GatherNd operation.
@@ -138,7 +138,7 @@ public final class GatherNd<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of GatherNd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> GatherNd<T> create(Scope scope, Operand<T> params, Operand<U> indices) {
+  public static <T extends Tensor, U extends Tensor & TNumber> GatherNd<T> create(Scope scope, Operand<T> params, Operand<U> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("GatherNd", scope.makeOpName("GatherNd"));
     opBuilder.addInput(params.asOutput());
     opBuilder.addInput(indices.asOutput());
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 57754705177..e69c217ec92 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Store the input tensor in the state of the current session.
  */
 @Operator
-public final class GetSessionHandle extends RawOp implements Operand<TType> {
+public final class GetSessionHandle extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new GetSessionHandle operation.
@@ -41,7 +41,7 @@ public final class GetSessionHandle extends RawOp implements Operand<TType> {
    * @return a new instance of GetSessionHandle
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> GetSessionHandle create(Scope scope, Operand<T> value) {
+  public static <T extends Tensor> GetSessionHandle create(Scope scope, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("GetSessionHandleV2", scope.makeOpName("GetSessionHandle"));
     opBuilder.addInput(value.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -58,8 +58,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 634b23ed56c..46deb48db0d 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Get the value of the tensor specified by its handle.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class GetSessionTensor<T extends TType> extends RawOp implements Operand<T> {
+public final class GetSessionTensor<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new GetSessionTensor operation.
@@ -46,7 +46,7 @@ public final class GetSessionTensor<T extends TType> extends RawOp implements Op
    * @return a new instance of GetSessionTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> GetSessionTensor<T> create(Scope scope, Operand<TString> handle, DataType<T> dtype) {
+  public static <T extends Tensor> GetSessionTensor<T> create(Scope scope, Operand<TString> handle, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("GetSessionTensor", scope.makeOpName("GetSessionTensor"));
     opBuilder.addInput(handle.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 ff9064f3ac9..4bd03d89ad7 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gives a guarantee to the TF runtime that the input tensor is a constant.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class GuaranteeConst<T extends TType> extends RawOp implements Operand<T> {
+public final class GuaranteeConst<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new GuaranteeConst operation.
@@ -50,7 +50,7 @@ public final class GuaranteeConst<T extends TType> extends RawOp implements Oper
    * @return a new instance of GuaranteeConst
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> GuaranteeConst<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> GuaranteeConst<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("GuaranteeConst", scope.makeOpName("GuaranteeConst"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 2b097647e32..134386e256a 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a non-initialized hash table.
@@ -36,7 +36,7 @@
  * table will be immutable.
  */
 @Operator
-public final class HashTable extends RawOp implements Operand<TType> {
+public final class HashTable extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.HashTable}
@@ -88,7 +88,7 @@ private Options() {
    * @return a new instance of HashTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> HashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
+  public static <T extends Tensor, U extends Tensor> HashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("HashTableV2", scope.makeOpName("HashTable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("key_dtype", keyDtype);
@@ -142,8 +142,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) tableHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 b7f7a90a90d..a347ff9c50c 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return histogram of values.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code out()} output
  */
 @Operator
-public final class HistogramFixedWidth<U extends TNumber> extends RawOp implements Operand<U> {
+public final class HistogramFixedWidth<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new HistogramFixedWidth operation.
@@ -67,7 +67,7 @@ public final class HistogramFixedWidth<U extends TNumber> extends RawOp implemen
    * @return a new instance of HistogramFixedWidth
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> HistogramFixedWidth<U> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins, DataType<U> dtype) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> HistogramFixedWidth<U> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("HistogramFixedWidth", scope.makeOpName("HistogramFixedWidth"));
     opBuilder.addInput(values.asOutput());
     opBuilder.addInput(valueRange.asOutput());
@@ -89,7 +89,7 @@ public static <U extends TNumber, T extends TNumber> HistogramFixedWidth<U> crea
    * @return a new instance of HistogramFixedWidth
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> HistogramFixedWidth<TInt32> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins) {
+  public static <T extends Tensor & TNumber> HistogramFixedWidth<TInt32> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins) {
     return create(scope, values, valueRange, nbins, TInt32.DTYPE);
   }
   
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 32c3d0d4cab..6a3720ffebe 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return a tensor with the same shape and contents as the input tensor or value.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Identity<T extends TType> extends RawOp implements Operand<T> {
+public final class Identity<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Identity operation.
@@ -43,7 +43,7 @@ public final class Identity<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Identity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Identity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Identity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Identity", scope.makeOpName("Identity"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 4ad5ab1f261..dd12da05233 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
@@ -24,12 +24,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a list of tensors with the same shapes and contents as the input
@@ -51,7 +51,7 @@
  * 
  */
 @Operator
-public final class IdentityN extends RawOp implements Iterable<Operand<TType>> {
+public final class IdentityN extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new IdentityN operation.
@@ -76,7 +76,7 @@ public List<Output<?>> output() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) output.iterator();
   }
   
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 c301ab66ca4..fc1e39fba9c 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns immutable tensor from memory region.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class ImmutableConst<T extends TType> extends RawOp implements Operand<T> {
+public final class ImmutableConst<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ImmutableConst operation.
@@ -50,7 +50,7 @@ public final class ImmutableConst<T extends TType> extends RawOp implements Oper
    * @return a new instance of ImmutableConst
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ImmutableConst<T> create(Scope scope, DataType<T> dtype, Shape shape, String memoryRegionName) {
+  public static <T extends Tensor> ImmutableConst<T> create(Scope scope, DataType<T> dtype, Shape shape, String memoryRegionName) {
     OperationBuilder opBuilder = scope.env().opBuilder("ImmutableConst", scope.makeOpName("ImmutableConst"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
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 2ffb3c37290..00e2ec45e07 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Table initializer that takes two tensors for keys and values respectively.
@@ -42,7 +42,7 @@ public final class InitializeTable extends RawOp {
    * @return a new instance of InitializeTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> InitializeTable create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+  public static <T extends Tensor, U extends Tensor> InitializeTable create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("InitializeTableV2", scope.makeOpName("InitializeTable"));
     opBuilder.addInput(tableHandle.asOutput());
     opBuilder.addInput(keys.asOutput());
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 5eab2e36d95..e5940ee9911 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  *     Adds v into specified rows of x.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class InplaceAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InplaceAdd operation.
@@ -48,7 +48,7 @@ public final class InplaceAdd<T extends TType> extends RawOp implements Operand<
    * @return a new instance of InplaceAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> InplaceAdd<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public static <T extends Tensor> InplaceAdd<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     OperationBuilder opBuilder = scope.env().opBuilder("InplaceAdd", scope.makeOpName("InplaceAdd"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(i.asOutput());
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 7ff3c5ef9bc..74d7e6ee18a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  *     Subtracts `v` into specified rows of `x`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceSub<T extends TType> extends RawOp implements Operand<T> {
+public final class InplaceSub<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InplaceSub operation.
@@ -48,7 +48,7 @@ public final class InplaceSub<T extends TType> extends RawOp implements Operand<
    * @return a new instance of InplaceSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> InplaceSub<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public static <T extends Tensor> InplaceSub<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     OperationBuilder opBuilder = scope.env().opBuilder("InplaceSub", scope.makeOpName("InplaceSub"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(i.asOutput());
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 877c9400f7f..469d1364aea 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  *     Updates specified rows with values in `v`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceUpdate<T extends TType> extends RawOp implements Operand<T> {
+public final class InplaceUpdate<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InplaceUpdate operation.
@@ -48,7 +48,7 @@ public final class InplaceUpdate<T extends TType> extends RawOp implements Opera
    * @return a new instance of InplaceUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> InplaceUpdate<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public static <T extends Tensor> InplaceUpdate<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     OperationBuilder opBuilder = scope.env().opBuilder("InplaceUpdate", scope.makeOpName("InplaceUpdate"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(i.asOutput());
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 f4f6bf5fe36..3e656564880 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * Checks whether a tensor has been initialized.
@@ -44,7 +44,7 @@ public final class IsVariableInitialized extends RawOp implements Operand<TBool>
    * @return a new instance of IsVariableInitialized
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> IsVariableInitialized create(Scope scope, Operand<T> ref) {
+  public static <T extends Tensor> IsVariableInitialized create(Scope scope, Operand<T> ref) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsVariableInitialized", scope.makeOpName("IsVariableInitialized"));
     opBuilder.addInput(ref.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c8b4d2dfa95..3162c4eec68 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Generates values in an interval.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class LinSpace<T extends TNumber> extends RawOp implements Operand<T> {
+public final class LinSpace<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new LinSpace operation.
@@ -56,7 +56,7 @@ public final class LinSpace<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of LinSpace
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> LinSpace<T> create(Scope scope, Operand<T> start, Operand<T> stop, Operand<U> num) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> LinSpace<T> create(Scope scope, Operand<T> start, Operand<T> stop, Operand<U> num) {
     OperationBuilder opBuilder = scope.env().opBuilder("LinSpace", scope.makeOpName("LinSpace"));
     opBuilder.addInput(start.asOutput());
     opBuilder.addInput(stop.asOutput());
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 0f31790fe45..45a2a2bb892 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs all keys and values in the table.
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code values()} output
  */
 @Operator
-public final class LookupTableExport<T extends TType, U extends TType> extends RawOp {
+public final class LookupTableExport<T extends Tensor, U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LookupTableExport operation.
@@ -47,7 +47,7 @@ public final class LookupTableExport<T extends TType, U extends TType> extends R
    * @return a new instance of LookupTableExport
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> LookupTableExport<T, U> create(Scope scope, Operand<?> tableHandle, DataType<T> Tkeys, DataType<U> Tvalues) {
+  public static <T extends Tensor, U extends Tensor> LookupTableExport<T, U> create(Scope scope, Operand<?> tableHandle, DataType<T> Tkeys, DataType<U> Tvalues) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableExportV2", scope.makeOpName("LookupTableExport"));
     opBuilder.addInput(tableHandle.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 e0dbead12d2..581d1489924 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Looks up keys in a table, outputs the corresponding values.
@@ -39,7 +39,7 @@
  * @param <U> data type for {@code values()} output
  */
 @Operator
-public final class LookupTableFind<U extends TType> extends RawOp implements Operand<U> {
+public final class LookupTableFind<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new LookupTableFind operation.
@@ -51,7 +51,7 @@ public final class LookupTableFind<U extends TType> extends RawOp implements Ope
    * @return a new instance of LookupTableFind
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> LookupTableFind<U> create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> defaultValue) {
+  public static <U extends Tensor, T extends Tensor> LookupTableFind<U> create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> defaultValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableFindV2", scope.makeOpName("LookupTableFind"));
     opBuilder.addInput(tableHandle.asOutput());
     opBuilder.addInput(keys.asOutput());
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 3df4d4653e0..604697c002e 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Replaces the contents of the table with the specified keys and values.
@@ -45,7 +45,7 @@ public final class LookupTableImport extends RawOp {
    * @return a new instance of LookupTableImport
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> LookupTableImport create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+  public static <T extends Tensor, U extends Tensor> LookupTableImport create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableImportV2", scope.makeOpName("LookupTableImport"));
     opBuilder.addInput(tableHandle.asOutput());
     opBuilder.addInput(keys.asOutput());
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 9e355312479..13c58a8ff9a 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Updates the table to associates keys with values.
@@ -45,7 +45,7 @@ public final class LookupTableInsert extends RawOp {
    * @return a new instance of LookupTableInsert
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> LookupTableInsert create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+  public static <T extends Tensor, U extends Tensor> LookupTableInsert create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableInsertV2", scope.makeOpName("LookupTableInsert"));
     opBuilder.addInput(tableHandle.asOutput());
     opBuilder.addInput(keys.asOutput());
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 875bbfa486c..15f9c2590c4 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Removes keys and its associated values from a table.
@@ -43,7 +43,7 @@ public final class LookupTableRemove extends RawOp {
    * @return a new instance of LookupTableRemove
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> LookupTableRemove create(Scope scope, Operand<?> tableHandle, Operand<T> keys) {
+  public static <T extends Tensor> LookupTableRemove create(Scope scope, Operand<?> tableHandle, Operand<T> keys) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableRemoveV2", scope.makeOpName("LookupTableRemove"));
     opBuilder.addInput(tableHandle.asOutput());
     opBuilder.addInput(keys.asOutput());
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 dfce8ac4d1f..7cb4485236e 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies lower_bound(sorted_search_values, values) along each row.
@@ -53,7 +53,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class LowerBound<U extends TNumber> extends RawOp implements Operand<U> {
+public final class LowerBound<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new LowerBound operation.
@@ -66,7 +66,7 @@ public final class LowerBound<U extends TNumber> extends RawOp implements Operan
    * @return a new instance of LowerBound
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> LowerBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
+  public static <U extends Tensor & TNumber, T extends Tensor> LowerBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("LowerBound", scope.makeOpName("LowerBound"));
     opBuilder.addInput(sortedInputs.asOutput());
     opBuilder.addInput(values.asOutput());
@@ -85,7 +85,7 @@ public static <U extends TNumber, T extends TType> LowerBound<U> create(Scope sc
    * @return a new instance of LowerBound
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> LowerBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
+  public static <T extends Tensor> LowerBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
     return create(scope, sortedInputs, values, TInt32.DTYPE);
   }
   
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 38087a7b46f..7e136a14822 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Op peeks at the values at the specified key.  If the
@@ -40,7 +40,7 @@
  * this op will block until it does.
  */
 @Operator
-public final class MapPeek extends RawOp implements Iterable<Operand<TType>> {
+public final class MapPeek extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapPeek}
@@ -164,7 +164,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 932c1f4f970..bff36a20782 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Op removes and returns the values associated with the key
@@ -40,7 +40,7 @@
  * does not contain this key, the op will block until it does.
  */
 @Operator
-public final class MapUnstage extends RawOp implements Iterable<Operand<TType>> {
+public final class MapUnstage extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapUnstage}
@@ -164,7 +164,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 e97fc9d17ca..6c91d8d82da 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the maximum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Max<T extends TType> extends RawOp implements Operand<T> {
+public final class Max<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Max}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of Max
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Max<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Max<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Max", scope.makeOpName("Max"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 476253b5601..bb8bf519b66 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the value of an available tensor from `inputs` to `output`.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Merge<T extends TType> extends RawOp {
+public final class Merge<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Merge operation.
@@ -51,7 +51,7 @@ public final class Merge<T extends TType> extends RawOp {
    * @return a new instance of Merge
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Merge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
+  public static <T extends Tensor> Merge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("Merge", scope.makeOpName("Merge"));
     opBuilder.addInputList(Operands.asOutputs(inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c19b8eaefdf..6e2733701c7 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the minimum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Min<T extends TType> extends RawOp implements Operand<T> {
+public final class Min<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Min}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of Min
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Min<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Min<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Min", scope.makeOpName("Min"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 beb9448138c..1049cde4500 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Pads a tensor with mirrored values.
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class MirrorPad<T extends TType> extends RawOp implements Operand<T> {
+public final class MirrorPad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MirrorPad operation.
@@ -77,7 +77,7 @@ public final class MirrorPad<T extends TType> extends RawOp implements Operand<T
    * @return a new instance of MirrorPad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> MirrorPad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
+  public static <T extends Tensor, U extends Tensor & TNumber> MirrorPad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
     OperationBuilder opBuilder = scope.env().opBuilder("MirrorPad", scope.makeOpName("MirrorPad"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(paddings.asOutput());
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 ee3a76eab9f..5a89f007c87 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gradient op for `MirrorPad` op. This op folds a mirror-padded tensor.
@@ -52,7 +52,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MirrorPadGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class MirrorPadGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MirrorPadGrad operation.
@@ -65,7 +65,7 @@ public final class MirrorPadGrad<T extends TType> extends RawOp implements Opera
    * @return a new instance of MirrorPadGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> MirrorPadGrad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
+  public static <T extends Tensor, U extends Tensor & TNumber> MirrorPadGrad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
     OperationBuilder opBuilder = scope.env().opBuilder("MirrorPadGrad", scope.makeOpName("MirrorPadGrad"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(paddings.asOutput());
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 fc482784607..9bed12a1771 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
@@ -25,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps an arbitrary MLIR computation expressed as a module with a main() function.
@@ -66,7 +66,7 @@
  * 
  */
 @Operator
-public final class MlirPassthroughOp extends RawOp implements Iterable<Operand<TType>> {
+public final class MlirPassthroughOp extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new MlirPassthroughOp operation.
@@ -99,7 +99,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 1b5fca24ce2..efb8f620677 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates an empty hash table that uses tensors as the backing store.
@@ -40,7 +40,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableDenseHashTable extends RawOp implements Operand<TType> {
+public final class MutableDenseHashTable extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableDenseHashTable}
@@ -122,7 +122,7 @@ private Options() {
    * @return a new instance of MutableDenseHashTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> MutableDenseHashTable create(Scope scope, Operand<T> emptyKey, Operand<T> deletedKey, DataType<U> valueDtype, Options... options) {
+  public static <T extends Tensor, U extends Tensor> MutableDenseHashTable create(Scope scope, Operand<T> emptyKey, Operand<T> deletedKey, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MutableDenseHashTableV2", scope.makeOpName("MutableDenseHashTable"));
     opBuilder.addInput(emptyKey.asOutput());
     opBuilder.addInput(deletedKey.asOutput());
@@ -208,8 +208,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) tableHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 74d304d82ab..89cb8f69bbf 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates an empty hash table.
@@ -36,7 +36,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableHashTable extends RawOp implements Operand<TType> {
+public final class MutableHashTable extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableHashTable}
@@ -88,7 +88,7 @@ private Options() {
    * @return a new instance of MutableHashTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> MutableHashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
+  public static <T extends Tensor, U extends Tensor> MutableHashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MutableHashTableV2", scope.makeOpName("MutableHashTable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("key_dtype", keyDtype);
@@ -142,8 +142,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) tableHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 6ef45423fba..89ba23e3c97 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates an empty hash table.
@@ -37,7 +37,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableHashTableOfTensors extends RawOp implements Operand<TType> {
+public final class MutableHashTableOfTensors extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableHashTableOfTensors}
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of MutableHashTableOfTensors
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> MutableHashTableOfTensors create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
+  public static <T extends Tensor, U extends Tensor> MutableHashTableOfTensors create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MutableHashTableOfTensorsV2", scope.makeOpName("MutableHashTableOfTensors"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("key_dtype", keyDtype);
@@ -160,8 +160,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) tableHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 41f57d9a755..aa613872961 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Mutex resource that can be locked by `MutexLock`.
  */
 @Operator
-public final class Mutex extends RawOp implements Operand<TType> {
+public final class Mutex extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Mutex}
@@ -112,8 +112,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) resource;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) resource;
   }
   
   private Output<?> resource;
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 e67ea7a228b..f2a07afa04a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Locks a mutex resource.  The output is the lock.  So long as the lock tensor
@@ -67,7 +67,7 @@
  * wish to ensure the usage is exclusive.
  */
 @Operator
-public final class MutexLock extends RawOp implements Operand<TType> {
+public final class MutexLock extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new MutexLock operation.
@@ -95,8 +95,8 @@ public Output<?> mutexLock() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) mutexLock;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) mutexLock;
   }
   
   private Output<?> mutexLock;
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 179e8f08e1d..bd552cbaf0a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs a tensor containing the reduction across all input tensors.
@@ -46,7 +46,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclAllReduce<T extends TNumber> extends RawOp implements Operand<T> {
+public final class NcclAllReduce<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NcclAllReduce operation.
@@ -59,7 +59,7 @@ public final class NcclAllReduce<T extends TNumber> extends RawOp implements Ope
    * @return a new instance of NcclAllReduce
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> NcclAllReduce<T> create(Scope scope, Operand<T> input, String reduction, Long numDevices, String sharedName) {
+  public static <T extends Tensor & TNumber> NcclAllReduce<T> create(Scope scope, Operand<T> input, String reduction, Long numDevices, String sharedName) {
     OperationBuilder opBuilder = scope.env().opBuilder("NcclAllReduce", scope.makeOpName("NcclAllReduce"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 70339b3853a..42b2740b667 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sends `input` to all devices that are connected to the output.
@@ -44,7 +44,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclBroadcast<T extends TNumber> extends RawOp implements Operand<T> {
+public final class NcclBroadcast<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NcclBroadcast operation.
@@ -55,7 +55,7 @@ public final class NcclBroadcast<T extends TNumber> extends RawOp implements Ope
    * @return a new instance of NcclBroadcast
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> NcclBroadcast<T> create(Scope scope, Operand<T> input, Shape shape) {
+  public static <T extends Tensor & TNumber> NcclBroadcast<T> create(Scope scope, Operand<T> input, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("NcclBroadcast", scope.makeOpName("NcclBroadcast"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c6376f1a908..5818d38a4f0 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reduces `input` from `num_devices` using `reduction` to a single device.
@@ -43,7 +43,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclReduce<T extends TNumber> extends RawOp implements Operand<T> {
+public final class NcclReduce<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NcclReduce operation.
@@ -54,7 +54,7 @@ public final class NcclReduce<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of NcclReduce
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> NcclReduce<T> create(Scope scope, Iterable<Operand<T>> input, String reduction) {
+  public static <T extends Tensor & TNumber> NcclReduce<T> create(Scope scope, Iterable<Operand<T>> input, String reduction) {
     OperationBuilder opBuilder = scope.env().opBuilder("NcclReduce", scope.makeOpName("NcclReduce"));
     opBuilder.addInputList(Operands.asOutputs(input));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 99f0fa0dd1b..94777054bce 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Makes its input available to the next iteration.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class NextIteration<T extends TType> extends RawOp implements Operand<T> {
+public final class NextIteration<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NextIteration operation.
@@ -43,7 +43,7 @@ public final class NextIteration<T extends TType> extends RawOp implements Opera
    * @return a new instance of NextIteration
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> NextIteration<T> create(Scope scope, Operand<T> data) {
+  public static <T extends Tensor> NextIteration<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("NextIteration", scope.makeOpName("NextIteration"));
     opBuilder.addInput(data.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 9b4d6a4927d..fd18a3f6a49 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a one-hot tensor.
@@ -116,7 +116,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class OneHot<U extends TType> extends RawOp implements Operand<U> {
+public final class OneHot<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OneHot}
@@ -149,7 +149,7 @@ private Options() {
    * @return a new instance of OneHot
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> OneHot<U> create(Scope scope, Operand<T> indices, Operand<TInt32> depth, Operand<U> onValue, Operand<U> offValue, Options... options) {
+  public static <U extends Tensor, T extends Tensor & TNumber> OneHot<U> create(Scope scope, Operand<T> indices, Operand<TInt32> depth, Operand<U> onValue, Operand<U> offValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OneHot", scope.makeOpName("OneHot"));
     opBuilder.addInput(indices.asOutput());
     opBuilder.addInput(depth.asOutput());
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 5d9ce5861c2..c1228b8cb27 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a tensor of ones with the same shape and type as x.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class OnesLike<T extends TType> extends RawOp implements Operand<T> {
+public final class OnesLike<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new OnesLike operation.
@@ -43,7 +43,7 @@ public final class OnesLike<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of OnesLike
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> OnesLike<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> OnesLike<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("OnesLike", scope.makeOpName("OnesLike"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 dd7fc0e3f40..91c92d7bc80 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Op peeks at the values at the specified key.  If the
@@ -41,7 +41,7 @@
  * performance.
  */
 @Operator
-public final class OrderedMapPeek extends RawOp implements Iterable<Operand<TType>> {
+public final class OrderedMapPeek extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapPeek}
@@ -165,7 +165,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 c44e344638d..76f6eb79913 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Op removes and returns the values associated with the key
@@ -40,7 +40,7 @@
  * does not contain this key, the op will block until it does.
  */
 @Operator
-public final class OrderedMapUnstage extends RawOp implements Iterable<Operand<TType>> {
+public final class OrderedMapUnstage extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapUnstage}
@@ -164,7 +164,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 c21f7aa9a58..b5f58cb90f2 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Pads a tensor.
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Pad<T extends TType> extends RawOp implements Operand<T> {
+public final class Pad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Pad operation.
@@ -71,7 +71,7 @@ public final class Pad<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Pad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Operand<T> constantValues) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Operand<T> constantValues) {
     OperationBuilder opBuilder = scope.env().opBuilder("PadV2", scope.makeOpName("Pad"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(paddings.asOutput());
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 ed9af9dde57..0e81d3f30cb 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates a list of `N` tensors along the first dimension.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ParallelConcat<T extends TType> extends RawOp implements Operand<T> {
+public final class ParallelConcat<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ParallelConcat operation.
@@ -63,7 +63,7 @@ public final class ParallelConcat<T extends TType> extends RawOp implements Oper
    * @return a new instance of ParallelConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ParallelConcat<T> create(Scope scope, Iterable<Operand<T>> values, Shape shape) {
+  public static <T extends Tensor> ParallelConcat<T> create(Scope scope, Iterable<Operand<T>> values, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParallelConcat", scope.makeOpName("ParallelConcat"));
     opBuilder.addInputList(Operands.asOutputs(values));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 3fd6514f285..de681532c08 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Interleave the values from the `data` tensors into a single tensor.
@@ -89,7 +89,7 @@
  * @param <T> data type for {@code merged()} output
  */
 @Operator
-public final class ParallelDynamicStitch<T extends TType> extends RawOp implements Operand<T> {
+public final class ParallelDynamicStitch<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ParallelDynamicStitch operation.
@@ -100,7 +100,7 @@ public final class ParallelDynamicStitch<T extends TType> extends RawOp implemen
    * @return a new instance of ParallelDynamicStitch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ParallelDynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
+  public static <T extends Tensor> ParallelDynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParallelDynamicStitch", scope.makeOpName("ParallelDynamicStitch"));
     opBuilder.addInputList(Operands.asOutputs(indices));
     opBuilder.addInputList(Operands.asOutputs(data));
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 c9c7727fcf8..2a4b3c6dbd1 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A placeholder op for a value that will be fed into the computation.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Placeholder<T extends TType> extends RawOp implements Operand<T> {
+public final class Placeholder<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Placeholder}
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of Placeholder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Placeholder<T> create(Scope scope, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> Placeholder<T> create(Scope scope, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Placeholder", scope.makeOpName("Placeholder"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
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 e794a0623cb..77e27ad510a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A placeholder op that passes through `input` when its output is not fed.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class PlaceholderWithDefault<T extends TType> extends RawOp implements Operand<T> {
+public final class PlaceholderWithDefault<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new PlaceholderWithDefault operation.
@@ -45,7 +45,7 @@ public final class PlaceholderWithDefault<T extends TType> extends RawOp impleme
    * @return a new instance of PlaceholderWithDefault
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> PlaceholderWithDefault<T> create(Scope scope, Operand<T> input, Shape shape) {
+  public static <T extends Tensor> PlaceholderWithDefault<T> create(Scope scope, Operand<T> input, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("PlaceholderWithDefault", scope.makeOpName("PlaceholderWithDefault"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 b9b7b8b65a4..2b112ea7512 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Prod<T extends TType> extends RawOp implements Operand<T> {
+public final class Prod<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Prod}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of Prod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Prod<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Prod<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Prod", scope.makeOpName("Prod"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 f4996cd8875..b2cfe0f375c 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reshapes a quantized tensor as per the Reshape op.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class QuantizedReshape<T extends TType> extends RawOp {
+public final class QuantizedReshape<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedReshape operation.
@@ -50,7 +50,7 @@ public final class QuantizedReshape<T extends TType> extends RawOp {
    * @return a new instance of QuantizedReshape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> QuantizedReshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
+  public static <T extends Tensor, U extends Tensor & TNumber> QuantizedReshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedReshape", scope.makeOpName("QuantizedReshape"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(shape.asOutput());
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 5134f49c314..6c3adb418c5 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a sequence of numbers.
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Range<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Range<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Range operation.
@@ -58,7 +58,7 @@ public final class Range<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Range
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Range<T> create(Scope scope, Operand<T> start, Operand<T> limit, Operand<T> delta) {
+  public static <T extends Tensor & TNumber> Range<T> create(Scope scope, Operand<T> start, Operand<T> limit, Operand<T> delta) {
     OperationBuilder opBuilder = scope.env().opBuilder("Range", scope.makeOpName("Range"));
     opBuilder.addInput(start.asOutput());
     opBuilder.addInput(limit.asOutput());
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 f7e1959280d..267121e42b5 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the rank of a tensor.
@@ -54,7 +54,7 @@ public final class Rank extends RawOp implements Operand<TInt32> {
    * @return a new instance of Rank
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Rank create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Rank create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Rank", scope.makeOpName("Rank"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c535547a925..c7657c29093 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reads the value of a variable.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class ReadVariableOp<T extends TType> extends RawOp implements Operand<T> {
+public final class ReadVariableOp<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ReadVariableOp operation.
@@ -52,7 +52,7 @@ public final class ReadVariableOp<T extends TType> extends RawOp implements Oper
    * @return a new instance of ReadVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ReadVariableOp<T> create(Scope scope, Operand<?> resource, DataType<T> dtype) {
+  public static <T extends Tensor> ReadVariableOp<T> create(Scope scope, Operand<?> resource, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReadVariableOp", scope.makeOpName("ReadVariableOp"));
     opBuilder.addInput(resource.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 5feb610b6fd..9a3daab0e35 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Receives the named tensor from send_device on recv_device.
  * 
  * @param <T> data type for {@code tensor()} output
  */
-public final class Recv<T extends TType> extends RawOp implements Operand<T> {
+public final class Recv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Recv}
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of Recv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Recv<T> create(Scope scope, DataType<T> tensorType, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
+  public static <T extends Tensor> Recv<T> create(Scope scope, DataType<T> tensorType, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Recv", scope.makeOpName("Recv"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("tensor_type", tensorType);
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 195a7bbbce8..ce419d834ce 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the "logical and" of elements across dimensions of a tensor.
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of ReduceAll
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ReduceAll create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends Tensor & TNumber> ReduceAll create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("All", scope.makeOpName("ReduceAll"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 9dde0ff6238..b981ee64c90 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the "logical or" of elements across dimensions of a tensor.
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of ReduceAny
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ReduceAny create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends Tensor & TNumber> ReduceAny create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Any", scope.makeOpName("ReduceAny"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 1df06cb441d..5cfd7649a83 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the maximum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceMax<T extends TType> extends RawOp implements Operand<T> {
+public final class ReduceMax<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceMax}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of ReduceMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ReduceMax<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ReduceMax<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Max", scope.makeOpName("ReduceMax"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 2ebdaa01247..52390a5fe61 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the minimum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceMin<T extends TType> extends RawOp implements Operand<T> {
+public final class ReduceMin<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceMin}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of ReduceMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ReduceMin<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ReduceMin<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Min", scope.makeOpName("ReduceMin"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 37fcf044469..907ef7df4aa 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceProd<T extends TType> extends RawOp implements Operand<T> {
+public final class ReduceProd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceProd}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of ReduceProd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ReduceProd<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ReduceProd<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Prod", scope.makeOpName("ReduceProd"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 82bf9d35558..321403d3139 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceSum<T extends TType> extends RawOp implements Operand<T> {
+public final class ReduceSum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceSum}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of ReduceSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ReduceSum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ReduceSum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sum", scope.makeOpName("ReduceSum"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 bec8abb5f80..5dc409e4194 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates or finds a child frame, and makes `data` available to the child frame.
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefEnter<T extends TType> extends RawOp implements Operand<T> {
+public final class RefEnter<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.RefEnter}
@@ -77,7 +77,7 @@ private Options() {
    * @return a new instance of RefEnter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RefEnter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
+  public static <T extends Tensor> RefEnter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefEnter", scope.makeOpName("RefEnter"));
     opBuilder.addInput(data.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 80399854da4..0ea9df5491c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Exits the current frame to its parent frame.
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefExit<T extends TType> extends RawOp implements Operand<T> {
+public final class RefExit<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefExit operation.
@@ -44,7 +44,7 @@ public final class RefExit<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of RefExit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RefExit<T> create(Scope scope, Operand<T> data) {
+  public static <T extends Tensor> RefExit<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefExit", scope.makeOpName("RefExit"));
     opBuilder.addInput(data.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 e3840bfa886..a61c3af6c38 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return the same ref tensor as the input ref tensor.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefIdentity<T extends TType> extends RawOp implements Operand<T> {
+public final class RefIdentity<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefIdentity operation.
@@ -42,7 +42,7 @@ public final class RefIdentity<T extends TType> extends RawOp implements Operand
    * @return a new instance of RefIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RefIdentity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> RefIdentity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefIdentity", scope.makeOpName("RefIdentity"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 eab96521ea6..4bef835d1dd 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the value of an available tensor from `inputs` to `output`.
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefMerge<T extends TType> extends RawOp {
+public final class RefMerge<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RefMerge operation.
@@ -50,7 +50,7 @@ public final class RefMerge<T extends TType> extends RawOp {
    * @return a new instance of RefMerge
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RefMerge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
+  public static <T extends Tensor> RefMerge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefMerge", scope.makeOpName("RefMerge"));
     opBuilder.addInputList(Operands.asOutputs(inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 bb1423440fd..44db5220a8b 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Makes its input available to the next iteration.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class RefNextIteration<T extends TType> extends RawOp implements Operand<T> {
+public final class RefNextIteration<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefNextIteration operation.
@@ -43,7 +43,7 @@ public final class RefNextIteration<T extends TType> extends RawOp implements Op
    * @return a new instance of RefNextIteration
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RefNextIteration<T> create(Scope scope, Operand<T> data) {
+  public static <T extends Tensor> RefNextIteration<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefNextIteration", scope.makeOpName("RefNextIteration"));
     opBuilder.addInput(data.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 23864ed4820..4965058bdb5 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the `index`th element of `inputs` to `output`.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class RefSelect<T extends TType> extends RawOp implements Operand<T> {
+public final class RefSelect<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RefSelect operation.
@@ -46,7 +46,7 @@ public final class RefSelect<T extends TType> extends RawOp implements Operand<T
    * @return a new instance of RefSelect
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RefSelect<T> create(Scope scope, Operand<TInt32> index, Iterable<Operand<T>> inputs) {
+  public static <T extends Tensor> RefSelect<T> create(Scope scope, Operand<TInt32> index, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefSelect", scope.makeOpName("RefSelect"));
     opBuilder.addInput(index.asOutput());
     opBuilder.addInputList(Operands.asOutputs(inputs));
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 b45250bb083..2222f840dfb 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the ref tensor `data` to the output port determined by `pred`.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code outputFalse()} output
  */
 @Operator
-public final class RefSwitch<T extends TType> extends RawOp {
+public final class RefSwitch<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RefSwitch operation.
@@ -50,7 +50,7 @@ public final class RefSwitch<T extends TType> extends RawOp {
    * @return a new instance of RefSwitch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RefSwitch<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
+  public static <T extends Tensor> RefSwitch<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefSwitch", scope.makeOpName("RefSwitch"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(pred.asOutput());
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 0242749bda6..53bcdfbe149 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
@@ -25,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Execute a sub graph on a remote processor.
@@ -44,7 +44,7 @@
  * will be passed to consumer nodes as outputs of this node.
  */
 @Operator
-public final class RemoteFusedGraphExecute extends RawOp implements Iterable<Operand<TType>> {
+public final class RemoteFusedGraphExecute extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new RemoteFusedGraphExecute operation.
@@ -79,7 +79,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 eaeaa5ded4e..865678a03c3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reshapes a tensor.
@@ -94,7 +94,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Reshape<T extends TType> extends RawOp implements Operand<T> {
+public final class Reshape<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Reshape operation.
@@ -105,7 +105,7 @@ public final class Reshape<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Reshape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Reshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Reshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("Reshape", scope.makeOpName("Reshape"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(shape.asOutput());
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 cce86ab05ce..91ae06f106b 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Increments variable pointed to by 'resource' until it reaches 'limit'.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ResourceCountUpTo<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ResourceCountUpTo<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ResourceCountUpTo operation.
@@ -48,7 +48,7 @@ public final class ResourceCountUpTo<T extends TNumber> extends RawOp implements
    * @return a new instance of ResourceCountUpTo
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResourceCountUpTo<T> create(Scope scope, Operand<?> resource, Long limit, DataType<T> T) {
+  public static <T extends Tensor & TNumber> ResourceCountUpTo<T> create(Scope scope, Operand<?> resource, Long limit, DataType<T> T) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceCountUpTo", scope.makeOpName("ResourceCountUpTo"));
     opBuilder.addInput(resource.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 fd8ccc35cfa..5078574b732 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gather slices from the variable pointed to by `resource` according to `indices`.
@@ -49,7 +49,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ResourceGather<U extends TType> extends RawOp implements Operand<U> {
+public final class ResourceGather<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ResourceGather}
@@ -90,7 +90,7 @@ private Options() {
    * @return a new instance of ResourceGather
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> ResourceGather<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype, Options... options) {
+  public static <U extends Tensor, T extends Tensor & TNumber> ResourceGather<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceGather", scope.makeOpName("ResourceGather"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 f2c501ec524..9ae8c96b1e6 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ResourceGatherNd<U extends TType> extends RawOp implements Operand<U> {
+public final class ResourceGatherNd<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new ResourceGatherNd operation.
@@ -45,7 +45,7 @@ public final class ResourceGatherNd<U extends TType> extends RawOp implements Op
    * @return a new instance of ResourceGatherNd
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> ResourceGatherNd<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype) {
+  public static <U extends Tensor, T extends Tensor & TNumber> ResourceGatherNd<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceGatherNd", scope.makeOpName("ResourceGatherNd"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 630a3716695..61956f29edc 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds sparse updates to the variable referenced by `resource`.
@@ -63,7 +63,7 @@ public final class ResourceScatterAdd extends RawOp {
    * @return a new instance of ResourceScatterAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterAdd create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterAdd create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterAdd", scope.makeOpName("ResourceScatterAdd"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 dba2e37ec12..72e7f964556 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Divides sparse updates into the variable referenced by `resource`.
@@ -63,7 +63,7 @@ public final class ResourceScatterDiv extends RawOp {
    * @return a new instance of ResourceScatterDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterDiv create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterDiv create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterDiv", scope.makeOpName("ResourceScatterDiv"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 6068660a905..97ba2bc7ba3 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
@@ -63,7 +63,7 @@ public final class ResourceScatterMax extends RawOp {
    * @return a new instance of ResourceScatterMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterMax create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMax create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterMax", scope.makeOpName("ResourceScatterMax"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 3e0ffeae23a..724625509a2 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
@@ -63,7 +63,7 @@ public final class ResourceScatterMin extends RawOp {
    * @return a new instance of ResourceScatterMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterMin create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMin create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterMin", scope.makeOpName("ResourceScatterMin"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 1a8feb21838..6955a530fdf 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Multiplies sparse updates into the variable referenced by `resource`.
@@ -63,7 +63,7 @@ public final class ResourceScatterMul extends RawOp {
    * @return a new instance of ResourceScatterMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterMul create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMul create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterMul", scope.makeOpName("ResourceScatterMul"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 a230b7d58bf..ba9aeb61d67 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse addition to individual values or slices in a Variable.
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of ResourceScatterNdAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterNdAdd create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdAdd create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterNdAdd", scope.makeOpName("ResourceScatterNdAdd"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 9912c63f129..68ae77e652a 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse subtraction to individual values or slices in a Variable.
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of ResourceScatterNdSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterNdSub create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdSub create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterNdSub", scope.makeOpName("ResourceScatterNdSub"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 625010c6aac..39ba65073a5 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse `updates` to individual values or slices within a given
@@ -99,7 +99,7 @@ private Options() {
    * @return a new instance of ResourceScatterNdUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterNdUpdate create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdUpdate create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterNdUpdate", scope.makeOpName("ResourceScatterNdUpdate"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 727dc01ab32..c750a7965d2 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts sparse updates from the variable referenced by `resource`.
@@ -63,7 +63,7 @@ public final class ResourceScatterSub extends RawOp {
    * @return a new instance of ResourceScatterSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterSub create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterSub create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterSub", scope.makeOpName("ResourceScatterSub"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 c75107a4bb7..0d20631c227 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Assigns sparse updates to the variable referenced by `resource`.
@@ -54,7 +54,7 @@ public final class ResourceScatterUpdate extends RawOp {
    * @return a new instance of ResourceScatterUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceScatterUpdate create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterUpdate create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterUpdate", scope.makeOpName("ResourceScatterUpdate"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(indices.asOutput());
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 10c93185348..ee79039e54e 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Assign `value` to the sliced l-value reference of `ref`.
@@ -108,7 +108,7 @@ private Options() {
    * @return a new instance of ResourceStridedSliceAssign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> ResourceStridedSliceAssign create(Scope scope, Operand<?> ref, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> value, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor> ResourceStridedSliceAssign create(Scope scope, Operand<?> ref, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceStridedSliceAssign", scope.makeOpName("ResourceStridedSliceAssign"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(begin.asOutput());
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 e64e165182f..d604d5e1335 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reverses specific dimensions of a tensor.
@@ -81,7 +81,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Reverse<T extends TType> extends RawOp implements Operand<T> {
+public final class Reverse<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Reverse operation.
@@ -93,7 +93,7 @@ public final class Reverse<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Reverse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Reverse<T> create(Scope scope, Operand<T> tensor, Operand<U> axis) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Reverse<T> create(Scope scope, Operand<T> tensor, Operand<U> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReverseV2", scope.makeOpName("Reverse"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(axis.asOutput());
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 a78de7f9a4c..6e54f87fa71 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reverses variable length slices.
@@ -87,7 +87,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReverseSequence<T extends TType> extends RawOp implements Operand<T> {
+public final class ReverseSequence<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReverseSequence}
@@ -120,7 +120,7 @@ private Options() {
    * @return a new instance of ReverseSequence
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ReverseSequence<T> create(Scope scope, Operand<T> input, Operand<U> seqLengths, Long seqDim, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ReverseSequence<T> create(Scope scope, Operand<T> input, Operand<U> seqLengths, Long seqDim, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReverseSequence", scope.makeOpName("ReverseSequence"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(seqLengths.asOutput());
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 8f6559ca09f..d63e80712df 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Rolls the elements of a tensor along an axis.
@@ -55,7 +55,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Roll<T extends TType> extends RawOp implements Operand<T> {
+public final class Roll<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Roll operation.
@@ -73,7 +73,7 @@ public final class Roll<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Roll
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber, V extends TNumber> Roll<T> create(Scope scope, Operand<T> input, Operand<U> shift, Operand<V> axis) {
+  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Roll<T> create(Scope scope, Operand<T> input, Operand<U> shift, Operand<V> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("Roll", scope.makeOpName("Roll"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(shift.asOutput());
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 5d18510e225..e199025abe1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds sparse updates to a variable reference.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterAdd}
@@ -90,7 +90,7 @@ private Options() {
    * @return a new instance of ScatterAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterAdd", scope.makeOpName("ScatterAdd"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 800dada981d..35f0cd4cfdb 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Divides a variable reference by sparse updates.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterDiv<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterDiv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterDiv}
@@ -86,7 +86,7 @@ private Options() {
    * @return a new instance of ScatterDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterDiv<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterDiv<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterDiv", scope.makeOpName("ScatterDiv"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 99e97ee0d23..03b68727112 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reduces sparse updates into a variable reference using the `max` operation.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ScatterMax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMax}
@@ -90,7 +90,7 @@ private Options() {
    * @return a new instance of ScatterMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> ScatterMax<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMax<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterMax", scope.makeOpName("ScatterMax"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 3b96560077a..16538a5e7d3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reduces sparse updates into a variable reference using the `min` operation.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMin<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ScatterMin<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMin}
@@ -90,7 +90,7 @@ private Options() {
    * @return a new instance of ScatterMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> ScatterMin<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMin<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterMin", scope.makeOpName("ScatterMin"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 38305790fb5..dba113e4dfe 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Multiplies sparse updates into a variable reference.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMul<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterMul<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMul}
@@ -86,7 +86,7 @@ private Options() {
    * @return a new instance of ScatterMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterMul<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterMul<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterMul", scope.makeOpName("ScatterMul"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 c59c526ca86..2081ee76b11 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Scatter `updates` into a new tensor according to `indices`.
@@ -111,7 +111,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ScatterNd<U extends TType> extends RawOp implements Operand<U> {
+public final class ScatterNd<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new ScatterNd operation.
@@ -123,7 +123,7 @@ public final class ScatterNd<U extends TType> extends RawOp implements Operand<U
    * @return a new instance of ScatterNd
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> ScatterNd<U> create(Scope scope, Operand<T> indices, Operand<U> updates, Operand<T> shape) {
+  public static <U extends Tensor, T extends Tensor & TNumber> ScatterNd<U> create(Scope scope, Operand<T> indices, Operand<U> updates, Operand<T> shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNd", scope.makeOpName("ScatterNd"));
     opBuilder.addInput(indices.asOutput());
     opBuilder.addInput(updates.asOutput());
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 11b1ddc0ef8..15f1c663382 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse addition to individual values or slices in a Variable.
@@ -64,7 +64,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterNdAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdAdd}
@@ -100,7 +100,7 @@ private Options() {
    * @return a new instance of ScatterNdAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterNdAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdAdd", scope.makeOpName("ScatterNdAdd"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 400f7e8b11c..65a20f09626 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse addition to `input` using individual values or slices
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ScatterNdNonAliasingAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterNdNonAliasingAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ScatterNdNonAliasingAdd operation.
@@ -82,7 +82,7 @@ public final class ScatterNdNonAliasingAdd<T extends TType> extends RawOp implem
    * @return a new instance of ScatterNdNonAliasingAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterNdNonAliasingAdd<T> create(Scope scope, Operand<T> input, Operand<U> indices, Operand<T> updates) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdNonAliasingAdd<T> create(Scope scope, Operand<T> input, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdNonAliasingAdd", scope.makeOpName("ScatterNdNonAliasingAdd"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(indices.asOutput());
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 bbeafdaa08b..a83f24ca7b4 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse subtraction to individual values or slices in a Variable.
@@ -66,7 +66,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdSub<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterNdSub<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdSub}
@@ -102,7 +102,7 @@ private Options() {
    * @return a new instance of ScatterNdSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterNdSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdSub", scope.makeOpName("ScatterNdSub"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 c715f6c1c92..6b8cfd70bd1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse `updates` to individual values or slices within a given
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdUpdate<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterNdUpdate<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdUpdate}
@@ -104,7 +104,7 @@ private Options() {
    * @return a new instance of ScatterNdUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterNdUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdUpdate", scope.makeOpName("ScatterNdUpdate"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 5bdb1e39081..3c3c8651b00 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts sparse updates to a variable reference.
@@ -56,7 +56,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterSub<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterSub<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterSub}
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of ScatterSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterSub", scope.makeOpName("ScatterSub"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 fc548962aa7..d14bf7554af 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse updates to a variable reference.
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterUpdate<T extends TType> extends RawOp implements Operand<T> {
+public final class ScatterUpdate<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterUpdate}
@@ -93,7 +93,7 @@ private Options() {
    * @return a new instance of ScatterUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ScatterUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ScatterUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterUpdate", scope.makeOpName("ScatterUpdate"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(indices.asOutput());
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 fff55e1cf71..c0b5b3ccf79 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Select<T extends TType> extends RawOp implements Operand<T> {
+public final class Select<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Select operation.
@@ -44,7 +44,7 @@ public final class Select<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Select
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Select<T> create(Scope scope, Operand<TBool> condition, Operand<T> t, Operand<T> e) {
+  public static <T extends Tensor> Select<T> create(Scope scope, Operand<TBool> condition, Operand<T> t, Operand<T> e) {
     OperationBuilder opBuilder = scope.env().opBuilder("SelectV2", scope.makeOpName("Select"));
     opBuilder.addInput(condition.asOutput());
     opBuilder.addInput(t.asOutput());
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 04f1f5813b3..9376e4ebed4 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sends the named tensor from send_device to recv_device.
@@ -66,7 +66,7 @@ private Options() {
    * @return a new instance of Send
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Send create(Scope scope, Operand<T> tensor, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
+  public static <T extends Tensor> Send create(Scope scope, Operand<T> tensor, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Send", scope.makeOpName("Send"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1b13994eebc..e70f0df0453 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the difference between two lists of numbers or strings.
@@ -57,7 +57,7 @@
  * @param <U> data type for {@code idx()} output
  */
 @Operator
-public final class SetDiff1d<T extends TType, U extends TNumber> extends RawOp {
+public final class SetDiff1d<T extends Tensor, U extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SetDiff1d operation.
@@ -69,7 +69,7 @@ public final class SetDiff1d<T extends TType, U extends TNumber> extends RawOp {
    * @return a new instance of SetDiff1d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SetDiff1d<T, U> create(Scope scope, Operand<T> x, Operand<T> y, DataType<U> outIdx) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SetDiff1d<T, U> create(Scope scope, Operand<T> x, Operand<T> y, DataType<U> outIdx) {
     OperationBuilder opBuilder = scope.env().opBuilder("ListDiff", scope.makeOpName("SetDiff1d"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
@@ -87,7 +87,7 @@ public static <T extends TType, U extends TNumber> SetDiff1d<T, U> create(Scope
    * @return a new instance of SetDiff1d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SetDiff1d<T, TInt32> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> SetDiff1d<T, TInt32> create(Scope scope, Operand<T> x, Operand<T> y) {
     return create(scope, x, y, TInt32.DTYPE);
   }
   
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 bd666afe4b2..106d4ebacfb 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Number of unique elements along last dimension of input `set`.
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of SetSize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SetSize create(Scope scope, Operand<TInt64> setIndices, Operand<T> setValues, Operand<TInt64> setShape, Options... options) {
+  public static <T extends Tensor> SetSize create(Scope scope, Operand<TInt64> setIndices, Operand<T> setValues, Operand<TInt64> setShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SetSize", scope.makeOpName("SetSize"));
     opBuilder.addInput(setIndices.asOutput());
     opBuilder.addInput(setValues.asOutput());
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 aef7aec2816..864b7cecb3d 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the shape of a tensor.
@@ -45,7 +45,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Shape<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Shape<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Shape operation.
@@ -56,7 +56,7 @@ public final class Shape<U extends TNumber> extends RawOp implements Operand<U>
    * @return a new instance of Shape
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Shape<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Shape<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Shape", scope.makeOpName("Shape"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -72,7 +72,7 @@ public static <U extends TNumber, T extends TType> Shape<U> create(Scope scope,
    * @return a new instance of Shape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Shape<TInt32> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Shape<TInt32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
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 307e86b38a2..48af1105888 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
@@ -25,6 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -32,7 +33,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns shape of tensors.
@@ -42,7 +42,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ShapeN<U extends TNumber> extends RawOp implements Iterable<Operand<U>> {
+public final class ShapeN<U extends Tensor & TNumber> extends RawOp implements Iterable<Operand<U>> {
   
   /**
    * Factory method to create a class wrapping a new ShapeN operation.
@@ -53,7 +53,7 @@ public final class ShapeN<U extends TNumber> extends RawOp implements Iterable<O
    * @return a new instance of ShapeN
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> ShapeN<U> create(Scope scope, Iterable<Operand<T>> input, DataType<U> outType) {
+  public static <U extends Tensor & TNumber, T extends Tensor> ShapeN<U> create(Scope scope, Iterable<Operand<T>> input, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ShapeN", scope.makeOpName("ShapeN"));
     opBuilder.addInputList(Operands.asOutputs(input));
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -69,7 +69,7 @@ public static <U extends TNumber, T extends TType> ShapeN<U> create(Scope scope,
    * @return a new instance of ShapeN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ShapeN<TInt32> create(Scope scope, Iterable<Operand<T>> input) {
+  public static <T extends Tensor> ShapeN<TInt32> create(Scope scope, Iterable<Operand<T>> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
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 d79f317a591..5439bbf551a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the size of a tensor.
@@ -46,7 +46,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Size<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Size<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Size operation.
@@ -57,7 +57,7 @@ public final class Size<U extends TNumber> extends RawOp implements Operand<U> {
    * @return a new instance of Size
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Size<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Size<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Size", scope.makeOpName("Size"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -73,7 +73,7 @@ public static <U extends TNumber, T extends TType> Size<U> create(Scope scope, O
    * @return a new instance of Size
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Size<TInt32> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Size<TInt32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
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 e141b0a2243..60bc7e2c9b3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return a slice from 'input'.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Slice<T extends TType> extends RawOp implements Operand<T> {
+public final class Slice<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Slice operation.
@@ -57,7 +57,7 @@ public final class Slice<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Slice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Slice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> size) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Slice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> size) {
     OperationBuilder opBuilder = scope.env().opBuilder("Slice", scope.makeOpName("Slice"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(begin.asOutput());
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 8599dac37e6..5fd6a3ee2be 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a copy of the input tensor.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Snapshot<T extends TType> extends RawOp implements Operand<T> {
+public final class Snapshot<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Snapshot operation.
@@ -43,7 +43,7 @@ public final class Snapshot<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Snapshot
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Snapshot<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Snapshot<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Snapshot", scope.makeOpName("Snapshot"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 80e9a72e37f..a0b2565e5b4 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * SpaceToBatch for N-D tensors of type T.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class SpaceToBatchNd<T extends TType> extends RawOp implements Operand<T> {
+public final class SpaceToBatchNd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SpaceToBatchNd operation.
@@ -147,7 +147,7 @@ public final class SpaceToBatchNd<T extends TType> extends RawOp implements Oper
    * @return a new instance of SpaceToBatchNd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber, V extends TNumber> SpaceToBatchNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> paddings) {
+  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> SpaceToBatchNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> paddings) {
     OperationBuilder opBuilder = scope.env().opBuilder("SpaceToBatchND", scope.makeOpName("SpaceToBatchNd"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(blockShape.asOutput());
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 f810c353427..c35c631b53a 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,12 +24,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Splits a tensor into `num_split` tensors along one dimension.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Split<T extends TType> extends RawOp implements Iterable<Operand<T>> {
+public final class Split<T extends Tensor> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new Split operation.
@@ -51,7 +51,7 @@ public final class Split<T extends TType> extends RawOp implements Iterable<Oper
    * @return a new instance of Split
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Split<T> create(Scope scope, Operand<TInt32> axis, Operand<T> value, Long numSplit) {
+  public static <T extends Tensor> Split<T> create(Scope scope, Operand<TInt32> axis, Operand<T> value, Long numSplit) {
     OperationBuilder opBuilder = scope.env().opBuilder("Split", scope.makeOpName("Split"));
     opBuilder.addInput(axis.asOutput());
     opBuilder.addInput(value.asOutput());
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 49646eecfc2..f978edffb16 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,13 +24,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Splits a tensor into `num_split` tensors along one dimension.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class SplitV<T extends TType> extends RawOp implements Iterable<Operand<T>> {
+public final class SplitV<T extends Tensor> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new SplitV operation.
@@ -54,7 +54,7 @@ public final class SplitV<T extends TType> extends RawOp implements Iterable<Ope
    * @return a new instance of SplitV
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SplitV<T> create(Scope scope, Operand<T> value, Operand<U> sizeSplits, Operand<TInt32> axis, Long numSplit) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SplitV<T> create(Scope scope, Operand<T> value, Operand<U> sizeSplits, Operand<TInt32> axis, Long numSplit) {
     OperationBuilder opBuilder = scope.env().opBuilder("SplitV", scope.makeOpName("SplitV"));
     opBuilder.addInput(value.asOutput());
     opBuilder.addInput(sizeSplits.asOutput());
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 5bc2ba50645..77dfed40d17 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Removes dimensions of size 1 from the shape of a tensor.
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Squeeze<T extends TType> extends RawOp implements Operand<T> {
+public final class Squeeze<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Squeeze}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of Squeeze
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Squeeze<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> Squeeze<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Squeeze", scope.makeOpName("Squeeze"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 6e98ac9ab4b..ff77da11585 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Stack<T extends TType> extends RawOp implements Operand<T> {
+public final class Stack<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Stack}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of Stack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Stack<T> create(Scope scope, Iterable<Operand<T>> values, Options... options) {
+  public static <T extends Tensor> Stack<T> create(Scope scope, Iterable<Operand<T>> values, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Pack", scope.makeOpName("Stack"));
     opBuilder.addInputList(Operands.asOutputs(values));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 0d00e7f1db9..01de85eca54 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Op peeks at the values at the specified index.  If the
@@ -40,7 +40,7 @@
  * performance.
  */
 @Operator
-public final class StagePeek extends RawOp implements Iterable<Operand<TType>> {
+public final class StagePeek extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StagePeek}
@@ -162,7 +162,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 f884e7b98f7..f363ba72a1b 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Stops gradient computation.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class StopGradient<T extends TType> extends RawOp implements Operand<T> {
+public final class StopGradient<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new StopGradient operation.
@@ -68,7 +68,7 @@ public final class StopGradient<T extends TType> extends RawOp implements Operan
    * @return a new instance of StopGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> StopGradient<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> StopGradient<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("StopGradient", scope.makeOpName("StopGradient"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 e19467389c2..b1ad2a3a836 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return a strided slice from `input`.
@@ -121,7 +121,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class StridedSlice<T extends TType> extends RawOp implements Operand<T> {
+public final class StridedSlice<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSlice}
@@ -214,7 +214,7 @@ private Options() {
    * @return a new instance of StridedSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> StridedSlice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> StridedSlice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StridedSlice", scope.makeOpName("StridedSlice"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(begin.asOutput());
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 e89e6657ad7..aa83a682ccb 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Assign `value` to the sliced l-value reference of `ref`.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class StridedSliceAssign<T extends TType> extends RawOp implements Operand<T> {
+public final class StridedSliceAssign<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSliceAssign}
@@ -111,7 +111,7 @@ private Options() {
    * @return a new instance of StridedSliceAssign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> StridedSliceAssign<T> create(Scope scope, Operand<T> ref, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> StridedSliceAssign<T> create(Scope scope, Operand<T> ref, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StridedSliceAssign", scope.makeOpName("StridedSliceAssign"));
     opBuilder.addInput(ref.asOutput());
     opBuilder.addInput(begin.asOutput());
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 f475104bc81..355dc936a4b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the gradient of `StridedSlice`.
@@ -43,7 +43,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class StridedSliceGrad<U extends TType> extends RawOp implements Operand<U> {
+public final class StridedSliceGrad<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSliceGrad}
@@ -113,7 +113,7 @@ private Options() {
    * @return a new instance of StridedSliceGrad
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> StridedSliceGrad<U> create(Scope scope, Operand<T> shape, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> dy, Options... options) {
+  public static <U extends Tensor, T extends Tensor & TNumber> StridedSliceGrad<U> create(Scope scope, Operand<T> shape, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> dy, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StridedSliceGrad", scope.makeOpName("StridedSliceGrad"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(begin.asOutput());
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 4fe6e275bad..dbc1ee18499 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Sum<T extends TType> extends RawOp implements Operand<T> {
+public final class Sum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Sum}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of Sum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Sum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Sum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sum", scope.makeOpName("Sum"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 b0abd4c0d55..fa4e17c270f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * Forwards `data` to the output port determined by `pred`.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code outputFalse()} output
  */
 @Operator
-public final class SwitchCond<T extends TType> extends RawOp {
+public final class SwitchCond<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SwitchCond operation.
@@ -50,7 +50,7 @@ public final class SwitchCond<T extends TType> extends RawOp {
    * @return a new instance of SwitchCond
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SwitchCond<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
+  public static <T extends Tensor> SwitchCond<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
     OperationBuilder opBuilder = scope.env().opBuilder("Switch", scope.makeOpName("SwitchCond"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(pred.asOutput());
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 dedd9f6d588..c62ae36d717 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a tensor that may be mutated, but only persists within a single step.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code ref()} output
  */
 @Operator
-public final class TemporaryVariable<T extends TType> extends RawOp implements Operand<T> {
+public final class TemporaryVariable<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TemporaryVariable}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of TemporaryVariable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TemporaryVariable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> TemporaryVariable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TemporaryVariable", scope.makeOpName("TemporaryVariable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
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 24b9a610f1f..ad88118114d 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -29,7 +30,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * An array of Tensors of given size.
@@ -116,7 +116,7 @@ private Options() {
    * @return a new instance of TensorArray
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArray create(Scope scope, Operand<TInt32> size, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> TensorArray create(Scope scope, Operand<TInt32> size, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayV3", scope.makeOpName("TensorArray"));
     opBuilder.addInput(size.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1c39d8922bb..18cce0a1b72 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -29,7 +30,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Concat the elements from the TensorArray into value `value`.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayConcat<T extends TType> extends RawOp {
+public final class TensorArrayConcat<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayConcat}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of TensorArrayConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArrayConcat<T> create(Scope scope, Operand<?> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> TensorArrayConcat<T> create(Scope scope, Operand<?> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayConcatV3", scope.makeOpName("TensorArrayConcat"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(flowIn.asOutput());
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 cd697f550d3..21b1f3dfe33 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -29,7 +30,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gather specific elements from the TensorArray into output `value`.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayGather<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorArrayGather<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayGather}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of TensorArrayGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArrayGather<T> create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> TensorArrayGather<T> create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayGatherV3", scope.makeOpName("TensorArrayGather"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(indices.asOutput());
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 05643c5d774..c9e8ad7b98c 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -29,13 +30,12 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayPack<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorArrayPack<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayPack}
@@ -67,7 +67,7 @@ private Options() {
    * @return a new instance of TensorArrayPack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArrayPack<T> create(Scope scope, Operand<TString> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> TensorArrayPack<T> create(Scope scope, Operand<TString> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayPack", scope.makeOpName("TensorArrayPack"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(flowIn.asOutput());
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 22065261a6a..55148e3a208 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Read an element from the TensorArray into output `value`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayRead<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorArrayRead<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorArrayRead operation.
@@ -49,7 +49,7 @@ public final class TensorArrayRead<T extends TType> extends RawOp implements Ope
    * @return a new instance of TensorArrayRead
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArrayRead<T> create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<TFloat32> flowIn, DataType<T> dtype) {
+  public static <T extends Tensor> TensorArrayRead<T> create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<TFloat32> flowIn, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayReadV3", scope.makeOpName("TensorArrayRead"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(index.asOutput());
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 f31f6b1428a..b4f7e3262a2 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Scatter the data from the input value into specific TensorArray elements.
@@ -48,7 +48,7 @@ public final class TensorArrayScatter extends RawOp implements Operand<TFloat32>
    * @return a new instance of TensorArrayScatter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArrayScatter create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<T> value, Operand<TFloat32> flowIn) {
+  public static <T extends Tensor> TensorArrayScatter create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<T> value, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayScatterV3", scope.makeOpName("TensorArrayScatter"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(indices.asOutput());
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 ca755929b77..7e46420e331 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Split the data from the input value into TensorArray elements.
@@ -69,7 +69,7 @@ public final class TensorArraySplit extends RawOp implements Operand<TFloat32> {
    * @return a new instance of TensorArraySplit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArraySplit create(Scope scope, Operand<?> handle, Operand<T> value, Operand<TInt64> lengths, Operand<TFloat32> flowIn) {
+  public static <T extends Tensor> TensorArraySplit create(Scope scope, Operand<?> handle, Operand<T> value, Operand<TInt64> lengths, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArraySplitV3", scope.makeOpName("TensorArraySplit"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(value.asOutput());
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 7d9e2b68ae1..4097d9c5ed4 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -44,7 +44,7 @@ public final class TensorArrayUnpack extends RawOp implements Operand<TFloat32>
    * @return a new instance of TensorArrayUnpack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArrayUnpack create(Scope scope, Operand<TString> handle, Operand<T> value, Operand<TFloat32> flowIn) {
+  public static <T extends Tensor> TensorArrayUnpack create(Scope scope, Operand<TString> handle, Operand<T> value, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayUnpack", scope.makeOpName("TensorArrayUnpack"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(value.asOutput());
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 8f5c56e524a..50c56c7acb9 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Push an element onto the tensor_array.
@@ -46,7 +46,7 @@ public final class TensorArrayWrite extends RawOp implements Operand<TFloat32> {
    * @return a new instance of TensorArrayWrite
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorArrayWrite create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<T> value, Operand<TFloat32> flowIn) {
+  public static <T extends Tensor> TensorArrayWrite create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<T> value, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayWriteV3", scope.makeOpName("TensorArrayWrite"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(index.asOutput());
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 f56d34d8df0..bc6656b08ce 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a TensorForestTreeResource
  */
-public final class TensorForestTreeResourceHandleOp extends RawOp implements Operand<TType> {
+public final class TensorForestTreeResourceHandleOp extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorForestTreeResourceHandleOp}
@@ -106,8 +106,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) resource;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) resource;
   }
   
   private Output<?> resource;
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 249e6a07b1d..865466def45 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Concats all tensors in the list along the 0th dimension.
@@ -49,7 +49,7 @@
  * @param <U> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListConcat<U extends TType> extends RawOp {
+public final class TensorListConcat<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorListConcat operation.
@@ -62,7 +62,7 @@ public final class TensorListConcat<U extends TType> extends RawOp {
    * @return a new instance of TensorListConcat
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> TensorListConcat<U> create(Scope scope, Operand<?> inputHandle, Operand<T> elementShape, Operand<TInt64> leadingDims, DataType<U> elementDtype) {
+  public static <U extends Tensor, T extends Tensor & TNumber> TensorListConcat<U> create(Scope scope, Operand<?> inputHandle, Operand<T> elementShape, Operand<TInt64> leadingDims, DataType<U> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListConcatV2", scope.makeOpName("TensorListConcat"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(elementShape.asOutput());
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 3d685a10b34..6df2a54a8dc 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,16 +22,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator
-public final class TensorListConcatLists extends RawOp implements Operand<TType> {
+public final class TensorListConcatLists extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListConcatLists operation.
@@ -43,7 +43,7 @@ public final class TensorListConcatLists extends RawOp implements Operand<TType>
    * @return a new instance of TensorListConcatLists
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListConcatLists create(Scope scope, Operand<?> inputA, Operand<?> inputB, DataType<T> elementDtype) {
+  public static <T extends Tensor> TensorListConcatLists create(Scope scope, Operand<?> inputA, Operand<?> inputB, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListConcatLists", scope.makeOpName("TensorListConcatLists"));
     opBuilder.addInput(inputA.asOutput());
     opBuilder.addInput(inputB.asOutput());
@@ -60,8 +60,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 4115dfebda5..d11b994055b 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * The shape of the elements of the given list, as a tensor.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code elementShape()} output
  */
 @Operator
-public final class TensorListElementShape<T extends TNumber> extends RawOp implements Operand<T> {
+public final class TensorListElementShape<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorListElementShape operation.
@@ -49,7 +49,7 @@ public final class TensorListElementShape<T extends TNumber> extends RawOp imple
    * @return a new instance of TensorListElementShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> TensorListElementShape<T> create(Scope scope, Operand<?> inputHandle, DataType<T> shapeType) {
+  public static <T extends Tensor & TNumber> TensorListElementShape<T> create(Scope scope, Operand<?> inputHandle, DataType<T> shapeType) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListElementShape", scope.makeOpName("TensorListElementShape"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 8569b6b936c..4c54936a199 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a TensorList which, when stacked, has the value of `tensor`.
@@ -37,7 +37,7 @@
  * output_handle: The list.
  */
 @Operator
-public final class TensorListFromTensor extends RawOp implements Operand<TType> {
+public final class TensorListFromTensor extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListFromTensor operation.
@@ -48,7 +48,7 @@ public final class TensorListFromTensor extends RawOp implements Operand<TType>
    * @return a new instance of TensorListFromTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> TensorListFromTensor create(Scope scope, Operand<T> tensor, Operand<U> elementShape) {
+  public static <T extends Tensor, U extends Tensor & TNumber> TensorListFromTensor create(Scope scope, Operand<T> tensor, Operand<U> elementShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListFromTensor", scope.makeOpName("TensorListFromTensor"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(elementShape.asOutput());
@@ -64,8 +64,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 b1c4aa520fb..0f041e6ee89 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Tensor by indexing into the TensorList.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator
-public final class TensorListGather<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorListGather<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorListGather operation.
@@ -55,7 +55,7 @@ public final class TensorListGather<T extends TType> extends RawOp implements Op
    * @return a new instance of TensorListGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListGather<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> indices, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+  public static <T extends Tensor> TensorListGather<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> indices, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListGather", scope.makeOpName("TensorListGather"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(indices.asOutput());
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 1ee5e084768..c2c8e3a70fe 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code item()} output
  */
 @Operator
-public final class TensorListGetItem<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorListGetItem<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorListGetItem operation.
@@ -46,7 +46,7 @@ public final class TensorListGetItem<T extends TType> extends RawOp implements O
    * @return a new instance of TensorListGetItem
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListGetItem<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+  public static <T extends Tensor> TensorListGetItem<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListGetItem", scope.makeOpName("TensorListGetItem"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(index.asOutput());
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 f4fb817b2fc..a5e3393716b 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the last element of the input list as well as a list with all but that element.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListPopBack<T extends TType> extends RawOp {
+public final class TensorListPopBack<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorListPopBack operation.
@@ -54,7 +54,7 @@ public final class TensorListPopBack<T extends TType> extends RawOp {
    * @return a new instance of TensorListPopBack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListPopBack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+  public static <T extends Tensor> TensorListPopBack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListPopBack", scope.makeOpName("TensorListPopBack"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(elementShape.asOutput());
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 216a5d44c4b..cfe1f2ffb62 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
@@ -37,7 +37,7 @@
  * element_shape: a shape compatible with that of elements in the list.
  */
 @Operator
-public final class TensorListPushBack extends RawOp implements Operand<TType> {
+public final class TensorListPushBack extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListPushBack operation.
@@ -48,7 +48,7 @@ public final class TensorListPushBack extends RawOp implements Operand<TType> {
    * @return a new instance of TensorListPushBack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListPushBack create(Scope scope, Operand<?> inputHandle, Operand<T> tensor) {
+  public static <T extends Tensor> TensorListPushBack create(Scope scope, Operand<?> inputHandle, Operand<T> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListPushBack", scope.makeOpName("TensorListPushBack"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(tensor.asOutput());
@@ -64,8 +64,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 065e7d0b6ed..ca102a1b817 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator
-public final class TensorListPushBackBatch extends RawOp implements Operand<TType> {
+public final class TensorListPushBackBatch extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListPushBackBatch operation.
@@ -41,7 +41,7 @@ public final class TensorListPushBackBatch extends RawOp implements Operand<TTyp
    * @return a new instance of TensorListPushBackBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListPushBackBatch create(Scope scope, Operand<?> inputHandles, Operand<T> tensor) {
+  public static <T extends Tensor> TensorListPushBackBatch create(Scope scope, Operand<?> inputHandles, Operand<T> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListPushBackBatch", scope.makeOpName("TensorListPushBackBatch"));
     opBuilder.addInput(inputHandles.asOutput());
     opBuilder.addInput(tensor.asOutput());
@@ -57,8 +57,8 @@ public Output<?> outputHandles() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandles;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandles;
   }
   
   private Output<?> outputHandles;
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 0c3294795c1..39fa18038bb 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * List of the given size with empty elements.
@@ -39,7 +39,7 @@
  * element_dtype: the desired type of elements in the list.
  */
 @Operator
-public final class TensorListReserve extends RawOp implements Operand<TType> {
+public final class TensorListReserve extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListReserve operation.
@@ -51,7 +51,7 @@ public final class TensorListReserve extends RawOp implements Operand<TType> {
    * @return a new instance of TensorListReserve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> TensorListReserve create(Scope scope, Operand<T> elementShape, Operand<TInt32> numElements, DataType<U> elementDtype) {
+  public static <T extends Tensor & TNumber, U extends Tensor> TensorListReserve create(Scope scope, Operand<T> elementShape, Operand<TInt32> numElements, DataType<U> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListReserve", scope.makeOpName("TensorListReserve"));
     opBuilder.addInput(elementShape.asOutput());
     opBuilder.addInput(numElements.asOutput());
@@ -68,8 +68,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 fb0380aa5a7..2725a31c9a9 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Resizes the list.
@@ -37,7 +37,7 @@
  * 
  */
 @Operator
-public final class TensorListResize extends RawOp implements Operand<TType> {
+public final class TensorListResize extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListResize operation.
@@ -64,8 +64,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 12fd2667321..8c0fe29e183 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a TensorList by indexing into a Tensor.
@@ -45,7 +45,7 @@
  * output_handle: The TensorList.
  */
 @Operator
-public final class TensorListScatter extends RawOp implements Operand<TType> {
+public final class TensorListScatter extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListScatter operation.
@@ -58,7 +58,7 @@ public final class TensorListScatter extends RawOp implements Operand<TType> {
    * @return a new instance of TensorListScatter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> TensorListScatter create(Scope scope, Operand<T> tensor, Operand<TInt32> indices, Operand<U> elementShape, Operand<TInt32> numElements) {
+  public static <T extends Tensor, U extends Tensor & TNumber> TensorListScatter create(Scope scope, Operand<T> tensor, Operand<TInt32> indices, Operand<U> elementShape, Operand<TInt32> numElements) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListScatterV2", scope.makeOpName("TensorListScatter"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(indices.asOutput());
@@ -76,8 +76,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 4d8d27ed14a..a3fd37363ad 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Scatters tensor at indices in an input list.
@@ -40,7 +40,7 @@
  * output_handle: The TensorList.
  */
 @Operator
-public final class TensorListScatterIntoExistingList extends RawOp implements Operand<TType> {
+public final class TensorListScatterIntoExistingList extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListScatterIntoExistingList operation.
@@ -52,7 +52,7 @@ public final class TensorListScatterIntoExistingList extends RawOp implements Op
    * @return a new instance of TensorListScatterIntoExistingList
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListScatterIntoExistingList create(Scope scope, Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
+  public static <T extends Tensor> TensorListScatterIntoExistingList create(Scope scope, Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListScatterIntoExistingList", scope.makeOpName("TensorListScatterIntoExistingList"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(tensor.asOutput());
@@ -69,8 +69,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 d570a3083a4..cb58d32c56e 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator
-public final class TensorListSetItem extends RawOp implements Operand<TType> {
+public final class TensorListSetItem extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListSetItem operation.
@@ -43,7 +43,7 @@ public final class TensorListSetItem extends RawOp implements Operand<TType> {
    * @return a new instance of TensorListSetItem
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListSetItem create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<T> item) {
+  public static <T extends Tensor> TensorListSetItem create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<T> item) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListSetItem", scope.makeOpName("TensorListSetItem"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(index.asOutput());
@@ -60,8 +60,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 aed272880fb..a66063fecde 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Splits a tensor into a list.
@@ -41,7 +41,7 @@
  * output_handle: The list.
  */
 @Operator
-public final class TensorListSplit extends RawOp implements Operand<TType> {
+public final class TensorListSplit extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorListSplit operation.
@@ -53,7 +53,7 @@ public final class TensorListSplit extends RawOp implements Operand<TType> {
    * @return a new instance of TensorListSplit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> TensorListSplit create(Scope scope, Operand<T> tensor, Operand<U> elementShape, Operand<TInt64> lengths) {
+  public static <T extends Tensor, U extends Tensor & TNumber> TensorListSplit create(Scope scope, Operand<T> tensor, Operand<U> elementShape, Operand<TInt64> lengths) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListSplit", scope.makeOpName("TensorListSplit"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(elementShape.asOutput());
@@ -70,8 +70,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 95075e1bb6d..c54d61f789d 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Stacks all tensors in the list.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListStack<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorListStack<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorListStack}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of TensorListStack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorListStack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype, Options... options) {
+  public static <T extends Tensor> TensorListStack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListStack", scope.makeOpName("TensorListStack"));
     opBuilder.addInput(inputHandle.asOutput());
     opBuilder.addInput(elementShape.asOutput());
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 77ffefde6f5..c8904b41b82 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds sparse `updates` to an existing tensor according to `indices`.
@@ -93,7 +93,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorScatterNdAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorScatterNdAdd operation.
@@ -105,7 +105,7 @@ public final class TensorScatterNdAdd<T extends TType> extends RawOp implements
    * @return a new instance of TensorScatterNdAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> TensorScatterNdAdd<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+  public static <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdAdd<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorScatterAdd", scope.makeOpName("TensorScatterNdAdd"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(indices.asOutput());
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 307a2d4b801..692cd043187 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts sparse `updates` from an existing tensor according to `indices`.
@@ -93,7 +93,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdSub<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorScatterNdSub<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorScatterNdSub operation.
@@ -105,7 +105,7 @@ public final class TensorScatterNdSub<T extends TType> extends RawOp implements
    * @return a new instance of TensorScatterNdSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> TensorScatterNdSub<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+  public static <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdSub<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorScatterSub", scope.makeOpName("TensorScatterNdSub"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(indices.asOutput());
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 ac7d0635b66..1966fe6d32b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Scatter `updates` into an existing tensor according to `indices`.
@@ -108,7 +108,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdUpdate<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorScatterNdUpdate<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorScatterNdUpdate operation.
@@ -120,7 +120,7 @@ public final class TensorScatterNdUpdate<T extends TType> extends RawOp implemen
    * @return a new instance of TensorScatterNdUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> TensorScatterNdUpdate<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+  public static <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdUpdate<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorScatterUpdate", scope.makeOpName("TensorScatterNdUpdate"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder.addInput(indices.asOutput());
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 d3bf1403073..8eccd2bc1a0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Assign `value` to the sliced l-value reference of `input`.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorStridedSliceUpdate<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorStridedSliceUpdate<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorStridedSliceUpdate}
@@ -111,7 +111,7 @@ private Options() {
    * @return a new instance of TensorStridedSliceUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> TensorStridedSliceUpdate<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> TensorStridedSliceUpdate<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorStridedSliceUpdate", scope.makeOpName("TensorStridedSliceUpdate"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(begin.asOutput());
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 abd9d462993..f3321bd693e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Constructs a tensor by tiling a given tensor.
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Tile<T extends TType> extends RawOp implements Operand<T> {
+public final class Tile<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Tile operation.
@@ -72,7 +72,7 @@ public final class Tile<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Tile
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Tile<T> create(Scope scope, Operand<T> input, Operand<U> multiples) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Tile<T> create(Scope scope, Operand<T> input, Operand<U> multiples) {
     OperationBuilder opBuilder = scope.env().opBuilder("Tile", scope.makeOpName("Tile"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(multiples.asOutput());
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 5cb23e99e7e..ae3b09713df 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reverses the operation of Batch for a single output Tensor.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code unbatchedTensor()} output
  */
 @Operator
-public final class Unbatch<T extends TType> extends RawOp implements Operand<T> {
+public final class Unbatch<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unbatch}
@@ -95,7 +95,7 @@ private Options() {
    * @return a new instance of Unbatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Unbatch<T> create(Scope scope, Operand<T> batchedTensor, Operand<TInt64> batchIndex, Operand<TInt64> id, Long timeoutMicros, Options... options) {
+  public static <T extends Tensor> Unbatch<T> create(Scope scope, Operand<T> batchedTensor, Operand<TInt64> batchIndex, Operand<TInt64> id, Long timeoutMicros, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Unbatch", scope.makeOpName("Unbatch"));
     opBuilder.addInput(batchedTensor.asOutput());
     opBuilder.addInput(batchIndex.asOutput());
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 1309c7e80c8..83fd34a1bb1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gradient of Unbatch.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code batchedGrad()} output
  */
 @Operator
-public final class UnbatchGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class UnbatchGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.UnbatchGrad}
@@ -91,7 +91,7 @@ private Options() {
    * @return a new instance of UnbatchGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> UnbatchGrad<T> create(Scope scope, Operand<T> originalInput, Operand<TInt64> batchIndex, Operand<T> grad, Operand<TInt64> id, Options... options) {
+  public static <T extends Tensor> UnbatchGrad<T> create(Scope scope, Operand<T> originalInput, Operand<TInt64> batchIndex, Operand<T> grad, Operand<TInt64> id, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnbatchGrad", scope.makeOpName("UnbatchGrad"));
     opBuilder.addInput(originalInput.asOutput());
     opBuilder.addInput(batchIndex.asOutput());
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 9f203229625..a1dac55fd27 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Finds unique elements along an axis of a tensor.
@@ -77,7 +77,7 @@
  * @param <V> data type for {@code idx()} output
  */
 @Operator
-public final class Unique<T extends TType, V extends TNumber> extends RawOp {
+public final class Unique<T extends Tensor, V extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Unique operation.
@@ -90,7 +90,7 @@ public final class Unique<T extends TType, V extends TNumber> extends RawOp {
    * @return a new instance of Unique
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, V extends TNumber, U extends TNumber> Unique<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
+  public static <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> Unique<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
     OperationBuilder opBuilder = scope.env().opBuilder("UniqueV2", scope.makeOpName("Unique"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(axis.asOutput());
@@ -109,7 +109,7 @@ public static <T extends TType, V extends TNumber, U extends TNumber> Unique<T,
    * @return a new instance of Unique
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Unique<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Unique<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
     return create(scope, x, axis, TInt32.DTYPE);
   }
   
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 a98e6736594..54efce5d00e 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Finds unique elements along an axis of a tensor.
@@ -81,7 +81,7 @@
  * @param <V> data type for {@code idx()} output
  */
 @Operator
-public final class UniqueWithCounts<T extends TType, V extends TNumber> extends RawOp {
+public final class UniqueWithCounts<T extends Tensor, V extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new UniqueWithCounts operation.
@@ -94,7 +94,7 @@ public final class UniqueWithCounts<T extends TType, V extends TNumber> extends
    * @return a new instance of UniqueWithCounts
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, V extends TNumber, U extends TNumber> UniqueWithCounts<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
+  public static <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> UniqueWithCounts<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
     OperationBuilder opBuilder = scope.env().opBuilder("UniqueWithCountsV2", scope.makeOpName("UniqueWithCounts"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(axis.asOutput());
@@ -113,7 +113,7 @@ public static <T extends TType, V extends TNumber, U extends TNumber> UniqueWith
    * @return a new instance of UniqueWithCounts
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> UniqueWithCounts<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
+  public static <T extends Tensor, U extends Tensor & TNumber> UniqueWithCounts<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
     return create(scope, x, axis, TInt32.DTYPE);
   }
   
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 e272d05ec2a..a6efa567757 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts an array of flat indices into a tuple of coordinate arrays.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class UnravelIndex<T extends TNumber> extends RawOp implements Operand<T> {
+public final class UnravelIndex<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnravelIndex operation.
@@ -66,7 +66,7 @@ public final class UnravelIndex<T extends TNumber> extends RawOp implements Oper
    * @return a new instance of UnravelIndex
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> UnravelIndex<T> create(Scope scope, Operand<T> indices, Operand<T> dims) {
+  public static <T extends Tensor & TNumber> UnravelIndex<T> create(Scope scope, Operand<T> indices, Operand<T> dims) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnravelIndex", scope.makeOpName("UnravelIndex"));
     opBuilder.addInput(indices.asOutput());
     opBuilder.addInput(dims.asOutput());
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 fcf759828b7..83d5f04b68c 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,11 +24,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Unstack<T extends TType> extends RawOp implements Iterable<Operand<T>> {
+public final class Unstack<T extends Tensor> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unstack}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of Unstack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Unstack<T> create(Scope scope, Operand<T> value, Long num, Options... options) {
+  public static <T extends Tensor> Unstack<T> create(Scope scope, Operand<T> value, Long num, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Unpack", scope.makeOpName("Unstack"));
     opBuilder.addInput(value.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 806d2d451c4..b1f4560cd7e 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,11 +25,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Op is similar to a lightweight Dequeue.
@@ -38,7 +38,7 @@
  * capabilities and options.  This Op is optimized for performance.
  */
 @Operator
-public final class Unstage extends RawOp implements Iterable<Operand<TType>> {
+public final class Unstage extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unstage}
@@ -158,7 +158,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 7f978707572..631b3b69a57 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies upper_bound(sorted_search_values, values) along each row.
@@ -53,7 +53,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class UpperBound<U extends TNumber> extends RawOp implements Operand<U> {
+public final class UpperBound<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new UpperBound operation.
@@ -66,7 +66,7 @@ public final class UpperBound<U extends TNumber> extends RawOp implements Operan
    * @return a new instance of UpperBound
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> UpperBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
+  public static <U extends Tensor & TNumber, T extends Tensor> UpperBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("UpperBound", scope.makeOpName("UpperBound"));
     opBuilder.addInput(sortedInputs.asOutput());
     opBuilder.addInput(values.asOutput());
@@ -85,7 +85,7 @@ public static <U extends TNumber, T extends TType> UpperBound<U> create(Scope sc
    * @return a new instance of UpperBound
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> UpperBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
+  public static <T extends Tensor> UpperBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
     return create(scope, sortedInputs, values, TInt32.DTYPE);
   }
   
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 93a48a32093..d96c68cd4bc 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a Variable resource.
  */
 @Operator
-public final class VarHandleOp extends RawOp implements Operand<TType> {
+public final class VarHandleOp extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.VarHandleOp}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of VarHandleOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> VarHandleOp create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends Tensor> VarHandleOp create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("VarHandleOp", scope.makeOpName("VarHandleOp"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -114,8 +114,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) resource;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) resource;
   }
   
   private Output<?> resource;
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 4f663493860..c4d4fcadc85 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Holds state in the form of a tensor that persists across steps.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code ref()} output
  */
 @Operator
-public final class Variable<T extends TType> extends RawOp implements Operand<T> {
+public final class Variable<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Variable}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of Variable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Variable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> Variable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("VariableV2", scope.makeOpName("Variable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
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 76fb3c770d0..1535e676ff8 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the shape of the variable pointed to by `resource`.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class VariableShape<T extends TNumber> extends RawOp implements Operand<T> {
+public final class VariableShape<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new VariableShape operation.
@@ -56,7 +56,7 @@ public final class VariableShape<T extends TNumber> extends RawOp implements Ope
    * @return a new instance of VariableShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> VariableShape<T> create(Scope scope, Operand<?> input, DataType<T> outType) {
+  public static <T extends Tensor & TNumber> VariableShape<T> create(Scope scope, Operand<?> input, DataType<T> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("VariableShape", scope.makeOpName("VariableShape"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 2e22fe12311..5c0f04ffea5 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns locations of nonzero / true values in a tensor.
@@ -102,7 +102,7 @@ public final class Where extends RawOp implements Operand<TInt64> {
    * @return a new instance of Where
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Where create(Scope scope, Operand<T> condition) {
+  public static <T extends Tensor> Where create(Scope scope, Operand<T> condition) {
     OperationBuilder opBuilder = scope.env().opBuilder("Where", scope.makeOpName("Where"));
     opBuilder.addInput(condition.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 60767fe78bf..ca15edea6fa 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a tensor of zeros with the same shape and type as x.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class ZerosLike<T extends TType> extends RawOp implements Operand<T> {
+public final class ZerosLike<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ZerosLike operation.
@@ -43,7 +43,7 @@ public final class ZerosLike<T extends TType> extends RawOp implements Operand<T
    * @return a new instance of ZerosLike
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ZerosLike<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> ZerosLike<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("ZerosLike", scope.makeOpName("ZerosLike"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 0dff0c406cc..fc6b7cdd1a8 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * A transformation that asserts which transformations happen next.
@@ -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 RawOp implements Operand<TType> {
+public final class AssertNextDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new AssertNextDataset operation.
@@ -84,8 +84,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 ab9d7753834..0eee666069d 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that shards the input dataset.
@@ -42,7 +42,7 @@
  * This dataset will throw a NotFound error if we cannot shard the dataset
  * automatically.
  */
-public final class AutoShardDataset extends RawOp implements Operand<TType> {
+public final class AutoShardDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.AutoShardDataset}
@@ -117,8 +117,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 f85b08a64c5..d9f9ddcf257 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,6 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -30,13 +31,12 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches `batch_size` elements from `input_dataset`.
  */
 @Operator(group = "data")
-public final class BatchDataset extends RawOp implements Operand<TType> {
+public final class BatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.BatchDataset}
@@ -112,8 +112,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a92c52ce5fd..2814439f136 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Records the bytes size of each element of `input_dataset` in a StatsAggregator.
  */
-public final class BytesProducedStatsDataset extends RawOp implements Operand<TType> {
+public final class BytesProducedStatsDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BytesProducedStatsDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 2374a884850..ab9df5fd412 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
@@ -22,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -31,12 +32,11 @@
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "data")
-public final class CSVDataset extends RawOp implements Operand<TType> {
+public final class CSVDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new CSVDataset operation.
@@ -83,8 +83,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 798519589d0..c5f86d5315b 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that caches elements from `input_dataset`.
@@ -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 RawOp implements Operand<TType> {
+public final class CacheDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new CacheDataset operation.
@@ -79,8 +79,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 f75ce86e7d0..60ac1b2e25b 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class CacheDatasetV2 extends RawOp implements Operand<TType> {
+public final class CacheDatasetV2 extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new CacheDatasetV2 operation.
@@ -74,8 +74,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e0acfa0e521..6c99d42f352 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
@@ -23,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class ChooseFastestDataset extends RawOp implements Operand<TType> {
+public final class ChooseFastestDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ChooseFastestDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 0a9b49b8fe6..6061f292ce2 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that concatenates `input_dataset` with `another_dataset`.
  */
 @Operator(group = "data")
-public final class ConcatenateDataset extends RawOp implements Operand<TType> {
+public final class ConcatenateDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ConcatenateDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 fa931c0cd72..6385afc04c6 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset from the given `graph_def`.
  * <p>
  * Creates a dataset from the provided `graph_def`.
  */
-public final class DatasetFromGraph extends RawOp implements Operand<TType> {
+public final class DatasetFromGraph extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new DatasetFromGraph operation.
@@ -59,8 +59,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a37b7e51a96..e443a5be229 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,17 +25,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs the single element from the given dataset.
  */
-public final class DatasetToSingleElement extends RawOp implements Iterable<Operand<TType>> {
+public final class DatasetToSingleElement extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new DatasetToSingleElement operation.
@@ -73,7 +73,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 fe69f57646a..dfa1b4e3c30 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches input elements into a SparseTensor.
  */
-public final class DenseToSparseBatchDataset extends RawOp implements Operand<TType> {
+public final class DenseToSparseBatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new DenseToSparseBatchDataset operation.
@@ -78,8 +78,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 b2031c8fc11..d1457a5cd15 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
@@ -23,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
  */
-public final class DirectedInterleaveDataset extends RawOp implements Operand<TType> {
+public final class DirectedInterleaveDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new DirectedInterleaveDataset operation.
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 2adf749ab8a..837e10a5075 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset containing elements of first component of `input_dataset` having true in the last component.
  */
-public final class FilterByLastComponentDataset extends RawOp implements Operand<TType> {
+public final class FilterByLastComponentDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new FilterByLastComponentDataset operation.
@@ -70,8 +70,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 47dbcf7c9ab..c22422668d7 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class FixedLengthRecordDataset extends RawOp implements Operand<TType> {
+public final class FixedLengthRecordDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new FixedLengthRecordDataset operation.
@@ -66,8 +66,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e7a4c8d69dd..89f888b2ee0 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the elements of `input_dataset` ignoring errors.
  */
-public final class IgnoreErrorsDataset extends RawOp implements Operand<TType> {
+public final class IgnoreErrorsDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new IgnoreErrorsDataset operation.
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 5ada431831c..6d19c38ebbc 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "data")
-public final class Iterator extends RawOp implements Operand<TType> {
+public final class Iterator extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new Iterator operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e394c9b347a..e11f138010a 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class IteratorFromStringHandle extends RawOp implements Operand<TType> {
+public final class IteratorFromStringHandle extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.IteratorFromStringHandle}
@@ -102,8 +102,8 @@ public Output<?> resourceHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) resourceHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) resourceHandle;
   }
   
   private Output<?> resourceHandle;
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 2b8e80de880..fff3f61fef0 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,18 +25,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gets the next output from the given iterator .
  */
 @Operator(group = "data")
-public final class IteratorGetNext extends RawOp implements Iterable<Operand<TType>> {
+public final class IteratorGetNext extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNext operation.
@@ -73,7 +73,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 41382765531..66848107ede 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gets the next output from the given iterator as an Optional variant.
  */
 @Operator(group = "data")
-public final class IteratorGetNextAsOptional extends RawOp implements Operand<TType> {
+public final class IteratorGetNextAsOptional extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNextAsOptional operation.
@@ -71,8 +71,8 @@ public Output<?> optional() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) optional;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) optional;
   }
   
   private Output<?> optional;
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 97f1ee35918..0054accfaa4 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gets the next output from the given iterator.
@@ -41,7 +41,7 @@
  * operations (e.g. in eager mode).
  */
 @Operator(group = "data")
-public final class IteratorGetNextSync extends RawOp implements Iterable<Operand<TType>> {
+public final class IteratorGetNextSync extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNextSync operation.
@@ -78,7 +78,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 9d8725757db..100b7a20375 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the key-value pairs in one or more LMDB files.
@@ -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 RawOp implements Operand<TType> {
+public final class LMDBDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new LMDBDataset operation.
@@ -83,8 +83,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 5391e373273..d2f4856c37c 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Records the latency of producing `input_dataset` elements in a StatsAggregator.
  */
-public final class LatencyStatsDataset extends RawOp implements Operand<TType> {
+public final class LatencyStatsDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new LatencyStatsDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 9832f573eda..433d7c8694a 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes rectified linear gradients for a LeakyRelu operation.
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class LeakyReluGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class LeakyReluGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.LeakyReluGrad}
@@ -65,7 +65,7 @@ private Options() {
    * @return a new instance of LeakyReluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LeakyReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features, Options... options) {
+  public static <T extends Tensor & TNumber> LeakyReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LeakyReluGrad", scope.makeOpName("LeakyReluGrad"));
     opBuilder.addInput(gradients.asOutput());
     opBuilder.addInput(features.asOutput());
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 6a83be042c6..dd16a48fdd0 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class MatchingFilesDataset extends RawOp implements Operand<TType> {
+public final class MatchingFilesDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new MatchingFilesDataset operation.
@@ -55,8 +55,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 5f45170d93e..ebb959b1aee 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that overrides the maximum intra-op parallelism.
  */
-public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<TType> {
+public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new MaxIntraOpParallelismDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 ca8566ff06f..9e7df64f13a 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Identity transformation that models performance.
  * <p>
  * Identity transformation that models performance.
  */
-public final class ModelDataset extends RawOp implements Operand<TType> {
+public final class ModelDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ModelDataset}
@@ -125,8 +125,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e4de4452636..492742707d7 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a MultiDeviceIterator resource.
  */
-public final class MultiDeviceIterator extends RawOp implements Operand<TType> {
+public final class MultiDeviceIterator extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIterator operation.
@@ -81,8 +81,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a80f5d9cdc2..d83ecb8d9fa 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Generates a MultiDeviceIterator resource from its provided string handle.
  */
-public final class MultiDeviceIteratorFromStringHandle extends RawOp implements Operand<TType> {
+public final class MultiDeviceIteratorFromStringHandle extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.MultiDeviceIteratorFromStringHandle}
@@ -104,8 +104,8 @@ public Output<?> multiDeviceIterator() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) multiDeviceIterator;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) multiDeviceIterator;
   }
   
   private Output<?> multiDeviceIterator;
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 6f2eeb28daa..993b824c384 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,6 +25,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -32,12 +33,11 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gets next element for the provided shard number.
  */
-public final class MultiDeviceIteratorGetNextFromShard extends RawOp implements Iterable<Operand<TType>> {
+public final class MultiDeviceIteratorGetNextFromShard extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIteratorGetNextFromShard operation.
@@ -79,7 +79,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 e42a75dbf83..3f3f8645349 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,16 +23,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class NonSerializableDataset extends RawOp implements Operand<TType> {
+public final class NonSerializableDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new NonSerializableDataset operation.
@@ -69,8 +69,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 b7e557c816d..d2cbd47fbf5 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,20 +23,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset by applying optimizations to `input_dataset`.
  * <p>
  * Creates a dataset by applying optimizations to `input_dataset`.
  */
-public final class OptimizeDataset extends RawOp implements Operand<TType> {
+public final class OptimizeDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.OptimizeDataset}
@@ -113,8 +113,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 7832d3cbd58..2b0a40acd23 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
@@ -21,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Constructs an Optional variant from a tuple of tensors.
  */
 @Operator(group = "data")
-public final class OptionalFromValue extends RawOp implements Operand<TType> {
+public final class OptionalFromValue extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new OptionalFromValue operation.
@@ -57,8 +57,8 @@ public Output<?> optional() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) optional;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) optional;
   }
   
   private Output<?> optional;
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 c38d1177c28..b7a04b5c862 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,18 +25,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the value stored in an Optional variant or raises an error if none exists.
  */
 @Operator(group = "data")
-public final class OptionalGetValue extends RawOp implements Iterable<Operand<TType>> {
+public final class OptionalGetValue extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new OptionalGetValue operation.
@@ -73,7 +73,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 ee871daef2e..ddeb8360e5d 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates an Optional variant with no value.
  */
 @Operator(group = "data")
-public final class OptionalNone extends RawOp implements Operand<TType> {
+public final class OptionalNone extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new OptionalNone operation.
@@ -54,8 +54,8 @@ public Output<?> optional() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) optional;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) optional;
   }
   
   private Output<?> optional;
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 65da0acf0c8..d4cb445eae1 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
@@ -22,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -30,12 +31,11 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches and pads `batch_size` elements from the input.
  */
-public final class PaddedBatchDataset extends RawOp implements Operand<TType> {
+public final class PaddedBatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.PaddedBatchDataset}
@@ -114,8 +114,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a56c2e70054..d7b0daf9b65 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that asynchronously prefetches elements from `input_dataset`.
  */
-public final class PrefetchDataset extends RawOp implements Operand<TType> {
+public final class PrefetchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.PrefetchDataset}
@@ -127,8 +127,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 d637c1b081a..4ea02d5341b 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class PrivateThreadPoolDataset extends RawOp implements Operand<TType> {
+public final class PrivateThreadPoolDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new PrivateThreadPoolDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 6549d26c515..12e055eaf3c 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Dataset that returns pseudorandom numbers.
@@ -45,7 +45,7 @@
  * performed is determined by the `experimental_optimization.hoist_random_uniform`
  * option of `tf.data.Options`.
  */
-public final class RandomDataset extends RawOp implements Operand<TType> {
+public final class RandomDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new RandomDataset operation.
@@ -86,8 +86,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 964d99e90e4..0c24aa899ea 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset with a range of values. Corresponds to python's xrange.
  */
 @Operator(group = "data")
-public final class RangeDataset extends RawOp implements Operand<TType> {
+public final class RangeDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new RangeDataset operation.
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 baa5d56fea3..3d54c01ab3c 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that changes the batch size.
@@ -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 RawOp implements Operand<TType> {
+public final class RebatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.RebatchDataset}
@@ -112,8 +112,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 85d27c01df8..58b629facd1 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the outputs of `input_dataset` `count` times.
  */
 @Operator(group = "data")
-public final class RepeatDataset extends RawOp implements Operand<TType> {
+public final class RepeatDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new RepeatDataset operation.
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 b9a584f0ac0..e8e100c9cc8 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,6 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -30,7 +31,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that takes a Bernoulli sample of the contents of another dataset.
@@ -41,7 +41,7 @@
  * `experimental_optimization.filter_with_random_uniform_fusion` option of
  * `tf.data.Options`.
  */
-public final class SamplingDataset extends RawOp implements Operand<TType> {
+public final class SamplingDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SamplingDataset operation.
@@ -85,8 +85,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 8dc271706f3..6393b34d8f5 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts the given `resource_handle` representing an iterator to a variant tensor.
  */
 @Operator(group = "data")
-public final class SerializeIterator extends RawOp implements Operand<TType> {
+public final class SerializeIterator extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.SerializeIterator}
@@ -92,8 +92,8 @@ public Output<?> serialized() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) serialized;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) serialized;
   }
   
   private Output<?> serialized;
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 b635c38df18..1824909ba01 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SetStatsAggregatorDataset extends RawOp implements Operand<TType> {
+public final class SetStatsAggregatorDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SetStatsAggregatorDataset operation.
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 71864817d93..7703b7395ea 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a `Dataset` that includes only 1/`num_shards` of this dataset.
  */
-public final class ShardDataset extends RawOp implements Operand<TType> {
+public final class ShardDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ShardDataset}
@@ -109,8 +109,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 67bf83b9b5d..0c50b8fcb1f 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,20 +23,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that shuffles and repeats elements from `input_dataset`
  * <p>
  * pseudorandomly.
  */
-public final class ShuffleAndRepeatDataset extends RawOp implements Operand<TType> {
+public final class ShuffleAndRepeatDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ShuffleAndRepeatDataset operation.
@@ -86,8 +86,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 ccc51d49a37..0b49950ee76 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class ShuffleDataset extends RawOp implements Operand<TType> {
+public final class ShuffleDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ShuffleDataset operation.
@@ -74,8 +74,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 7de29fc4976..ef55406b9e3 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that skips `count` elements from the `input_dataset`.
  */
 @Operator(group = "data")
-public final class SkipDataset extends RawOp implements Operand<TType> {
+public final class SkipDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SkipDataset operation.
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 23f6e214ec4..feeb78b77ed 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SleepDataset extends RawOp implements Operand<TType> {
+public final class SleepDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SleepDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 2eb9ac29140..305152de904 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that passes a sliding window over `input_dataset`.
  */
-public final class SlidingWindowDataset extends RawOp implements Operand<TType> {
+public final class SlidingWindowDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SlidingWindowDataset operation.
@@ -80,8 +80,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 c166f4a4fd7..042a681eb8c 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that will write to / read from a snapshot.
@@ -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 RawOp implements Operand<TType> {
+public final class SnapshotDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.SnapshotDataset}
@@ -359,8 +359,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 9c45e99c9e3..e16be890f5e 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that splits a SparseTensor into elements row-wise.
  */
-public final class SparseTensorSliceDataset extends RawOp implements Operand<TType> {
+public final class SparseTensorSliceDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorSliceDataset operation.
@@ -43,7 +43,7 @@ public final class SparseTensorSliceDataset extends RawOp implements Operand<TTy
    * @return a new instance of SparseTensorSliceDataset
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseTensorSliceDataset create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
+  public static <T extends Tensor> SparseTensorSliceDataset create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorSliceDataset", scope.makeOpName("SparseTensorSliceDataset"));
     opBuilder.addInput(indices.asOutput());
     opBuilder.addInput(values.asOutput());
@@ -60,8 +60,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 9c8ef660137..b08bbaa8bd7 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that executes a SQL query and emits rows of the result set.
  */
-public final class SqlDataset extends RawOp implements Operand<TType> {
+public final class SqlDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SqlDataset operation.
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 b96fcb2a07e..57bc572a7d3 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a statistics manager resource.
  */
-public final class StatsAggregatorHandle extends RawOp implements Operand<TType> {
+public final class StatsAggregatorHandle extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.StatsAggregatorHandle}
@@ -106,8 +106,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 9fb312ddac7..90e1a5c649a 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains `count` elements from the `input_dataset`.
  */
 @Operator(group = "data")
-public final class TakeDataset extends RawOp implements Operand<TType> {
+public final class TakeDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TakeDataset operation.
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 35f30f733ae..bfe55bbef91 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
@@ -22,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits `components` as a tuple of tensors once.
  */
-public final class TensorDataset extends RawOp implements Operand<TType> {
+public final class TensorDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorDataset operation.
@@ -64,8 +64,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 45fc9c1eef5..b0b69240a8d 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
@@ -22,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits each dim-0 slice of `components` once.
  */
 @Operator(group = "data")
-public final class TensorSliceDataset extends RawOp implements Operand<TType> {
+public final class TensorSliceDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TensorSliceDataset operation.
@@ -65,8 +65,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 614d3bc2b4c..08fe2c10873 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the lines of one or more text files.
  */
 @Operator(group = "data")
-public final class TextLineDataset extends RawOp implements Operand<TType> {
+public final class TextLineDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TextLineDataset operation.
@@ -64,8 +64,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 ba889f8f3af..597734ace78 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the records from one or more TFRecord files.
  */
 @Operator(group = "data")
-public final class TfRecordDataset extends RawOp implements Operand<TType> {
+public final class TfRecordDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new TfRecordDataset operation.
@@ -65,8 +65,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 b0443de050e..3903f3153a7 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolDataset extends RawOp implements Operand<TType> {
+public final class ThreadPoolDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ThreadPoolDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 9c5ad809be0..ae10874ecb4 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolHandle extends RawOp implements Operand<TType> {
+public final class ThreadPoolHandle extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ThreadPoolHandle}
@@ -135,8 +135,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e92d5a72d41..90a4e50f409 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A dataset that splits the elements of its input into multiple elements.
  */
-public final class UnbatchDataset extends RawOp implements Operand<TType> {
+public final class UnbatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new UnbatchDataset operation.
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 fc7796939c2..24169fb9071 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the unique elements of `input_dataset`.
  */
-public final class UniqueDataset extends RawOp implements Operand<TType> {
+public final class UniqueDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new UniqueDataset operation.
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 1ba2fb16027..7e2e628e463 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class UnwrapDatasetVariant extends RawOp implements Operand<TType> {
+public final class UnwrapDatasetVariant extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new UnwrapDatasetVariant operation.
@@ -54,8 +54,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 c08069ff65f..29055c9d385 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,6 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -30,7 +31,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  *   Combines (nests of) input elements into a dataset of (nests of) windows.
@@ -76,7 +76,7 @@
  *   - `tf.data.Dataset.from_tensor_slices({"a": range(4)}).window(2)`
  *     produces `{{"a": {0, 1}}, {"a": {2, 3}}}`
  */
-public final class WindowDataset extends RawOp implements Operand<TType> {
+public final class WindowDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new WindowDataset operation.
@@ -127,8 +127,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 94ab283621f..e7a5c710b19 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class WrapDatasetVariant extends RawOp implements Operand<TType> {
+public final class WrapDatasetVariant extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new WrapDatasetVariant operation.
@@ -54,8 +54,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) outputHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 0829a5435c3..94b80a1377d 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
@@ -23,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that zips together `input_datasets`.
@@ -41,7 +41,7 @@
  * dataset, and no error will be raised if input datasets have different sizes.
  */
 @Operator(group = "data")
-public final class ZipDataset extends RawOp implements Operand<TType> {
+public final class ZipDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ZipDataset operation.
@@ -78,8 +78,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java
index 271026cab6c..fbf3e3e53a8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java
@@ -23,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class AssertCardinalityDataset extends RawOp implements Operand<TType> {
+public final class AssertCardinalityDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new AssertCardinalityDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 3ced6851207..1ae871d4754 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class AssertNextDataset extends RawOp implements Operand<TType> {
+public final class AssertNextDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new AssertNextDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e1a8ffbffbe..d88e8552f55 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that shards the input dataset.
@@ -42,7 +42,7 @@
  * This dataset will throw a NotFound error if we cannot shard the dataset
  * automatically.
  */
-public final class AutoShardDataset extends RawOp implements Operand<TType> {
+public final class AutoShardDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.AutoShardDataset}
@@ -117,8 +117,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 aaf9e88a544..b82bab6d628 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Records the bytes size of each element of `input_dataset` in a StatsAggregator.
  */
-public final class BytesProducedStatsDataset extends RawOp implements Operand<TType> {
+public final class BytesProducedStatsDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BytesProducedStatsDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 764d02ab240..31effddb334 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
@@ -22,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -31,11 +32,10 @@
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class CSVDataset extends RawOp implements Operand<TType> {
+public final class CSVDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new CSVDataset operation.
@@ -82,8 +82,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a4335e73817..17323f95ef9 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
@@ -23,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class ChooseFastestDataset extends RawOp implements Operand<TType> {
+public final class ChooseFastestDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ChooseFastestDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 550ddde8c54..30d81e35490 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches input elements into a SparseTensor.
  */
-public final class DenseToSparseBatchDataset extends RawOp implements Operand<TType> {
+public final class DenseToSparseBatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new DenseToSparseBatchDataset operation.
@@ -78,8 +78,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 62ba3a97b7f..d33d1eae050 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
@@ -23,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
  */
-public final class DirectedInterleaveDataset extends RawOp implements Operand<TType> {
+public final class DirectedInterleaveDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new DirectedInterleaveDataset operation.
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 77c750ea775..feb3d2ef49a 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the elements of `input_dataset` ignoring errors.
  */
-public final class IgnoreErrorsDataset extends RawOp implements Operand<TType> {
+public final class IgnoreErrorsDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new IgnoreErrorsDataset operation.
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 6a54aa3586c..fc0c6bdc53f 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Records the latency of producing `input_dataset` elements in a StatsAggregator.
  */
-public final class LatencyStatsDataset extends RawOp implements Operand<TType> {
+public final class LatencyStatsDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new LatencyStatsDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a7680b1cbe9..cdd23b3bd0b 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class LmdbDataset extends RawOp implements Operand<TType> {
+public final class LmdbDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new LmdbDataset operation.
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 fcd78e95ee7..a076417c9e2 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class MatchingFilesDataset extends RawOp implements Operand<TType> {
+public final class MatchingFilesDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new MatchingFilesDataset operation.
@@ -55,8 +55,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 f7db67ed8a8..258c75040a4 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that overrides the maximum intra-op parallelism.
  */
-public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<TType> {
+public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new MaxIntraOpParallelismDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 5d19824576d..2dfdfd270c3 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,16 +23,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class NonSerializableDataset extends RawOp implements Operand<TType> {
+public final class NonSerializableDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new NonSerializableDataset operation.
@@ -69,8 +69,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 f87553458b2..1d0c6f31faa 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
@@ -23,6 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -31,12 +32,11 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * 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 RawOp implements Operand<TType> {
+public final class ParseExampleDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.ParseExampleDataset}
@@ -191,8 +191,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 963fb615d65..2648fed52e9 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class PrivateThreadPoolDataset extends RawOp implements Operand<TType> {
+public final class PrivateThreadPoolDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new PrivateThreadPoolDataset operation.
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 aed4a2b7ee4..7035aec9273 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Dataset that returns pseudorandom numbers.
  */
-public final class RandomDataset extends RawOp implements Operand<TType> {
+public final class RandomDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new RandomDataset operation.
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 cb33dd922e4..31d5cf4200c 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that changes the batch size.
@@ -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 RawOp implements Operand<TType> {
+public final class RebatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.RebatchDataset}
@@ -112,8 +112,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 705753f7835..62657afba76 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SetStatsAggregatorDataset extends RawOp implements Operand<TType> {
+public final class SetStatsAggregatorDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SetStatsAggregatorDataset operation.
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e953bcf3949..939bf3951db 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SleepDataset extends RawOp implements Operand<TType> {
+public final class SleepDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SleepDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 efe23924930..617ea5204f9 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that passes a sliding window over `input_dataset`.
  */
-public final class SlidingWindowDataset extends RawOp implements Operand<TType> {
+public final class SlidingWindowDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SlidingWindowDataset operation.
@@ -80,8 +80,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 ca01538ebdb..1bc4612a6ea 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that executes a SQL query and emits rows of the result set.
  */
-public final class SqlDataset extends RawOp implements Operand<TType> {
+public final class SqlDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SqlDataset operation.
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 e3749bfc10b..7c1d95e7966 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class StatsAggregatorHandle extends RawOp implements Operand<TType> {
+public final class StatsAggregatorHandle extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.StatsAggregatorHandle}
@@ -105,8 +105,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a7daf34b40f..d05b207806e 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolDataset extends RawOp implements Operand<TType> {
+public final class ThreadPoolDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new ThreadPoolDataset operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 9a2527ec80e..ee2a5f0c5c3 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolHandle extends RawOp implements Operand<TType> {
+public final class ThreadPoolHandle extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.ThreadPoolHandle}
@@ -135,8 +135,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 7fbcf202d9c..94fec642de9 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A dataset that splits the elements of its input into multiple elements.
  */
-public final class UnbatchDataset extends RawOp implements Operand<TType> {
+public final class UnbatchDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new UnbatchDataset operation.
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 853152d2760..049d4b64211 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the unique elements of `input_dataset`.
  */
-public final class UniqueDataset extends RawOp implements Operand<TType> {
+public final class UniqueDataset extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new UniqueDataset operation.
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java
index 1124b625a73..1735b281db5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Checks a tensor for NaN, -Inf and +Inf values.
@@ -38,7 +38,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CheckNumerics<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CheckNumerics<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CheckNumerics operation.
@@ -49,7 +49,7 @@ public final class CheckNumerics<T extends TNumber> extends RawOp implements Ope
    * @return a new instance of CheckNumerics
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CheckNumerics<T> create(Scope scope, Operand<T> tensor, String message) {
+  public static <T extends Tensor & TNumber> CheckNumerics<T> create(Scope scope, Operand<T> tensor, String message) {
     OperationBuilder opBuilder = scope.env().opBuilder("CheckNumericsV2", scope.makeOpName("CheckNumerics"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java
index 9840b9b1607..b574bf74b0f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Identity op for gradient debugging.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugGradientIdentity<T extends TType> extends RawOp implements Operand<T> {
+public final class DebugGradientIdentity<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DebugGradientIdentity operation.
@@ -46,7 +46,7 @@ public final class DebugGradientIdentity<T extends TType> extends RawOp implemen
    * @return a new instance of DebugGradientIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DebugGradientIdentity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> DebugGradientIdentity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugGradientIdentity", scope.makeOpName("DebugGradientIdentity"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java
index 3746e4891f7..bd2fa8bc59c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Identity op for gradient debugging.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugGradientRefIdentity<T extends TType> extends RawOp implements Operand<T> {
+public final class DebugGradientRefIdentity<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DebugGradientRefIdentity operation.
@@ -46,7 +46,7 @@ public final class DebugGradientRefIdentity<T extends TType> extends RawOp imple
    * @return a new instance of DebugGradientRefIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DebugGradientRefIdentity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> DebugGradientRefIdentity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugGradientRefIdentity", scope.makeOpName("DebugGradientRefIdentity"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java
index cf3503ffca3..3682b5b1707 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java
@@ -22,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Debug Identity V2 Op.
@@ -43,7 +43,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugIdentity<T extends TType> extends RawOp implements Operand<T> {
+public final class DebugIdentity<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.debugging.DebugIdentity}
@@ -112,7 +112,7 @@ private Options() {
    * @return a new instance of DebugIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DebugIdentity<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> DebugIdentity<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugIdentityV2", scope.makeOpName("DebugIdentity"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java
index 12e011c67ac..a35b06da0ff 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java
@@ -22,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Debug NaN Value Counter Op.
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of DebugNanCount
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DebugNanCount create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> DebugNanCount create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugNanCount", scope.makeOpName("DebugNanCount"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java
index 32e3291a909..6c1e2845eac 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Debug Numeric Summary V2 Op.
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class DebugNumericsSummary<U extends TNumber> extends RawOp implements Operand<U> {
+public final class DebugNumericsSummary<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.debugging.DebugNumericsSummary}
@@ -132,7 +132,7 @@ private Options() {
    * @return a new instance of DebugNumericsSummary
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> DebugNumericsSummary<U> create(Scope scope, Operand<T> input, DataType<U> outputDtype, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor> DebugNumericsSummary<U> create(Scope scope, Operand<T> input, DataType<U> outputDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugNumericSummaryV2", scope.makeOpName("DebugNumericsSummary"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -159,7 +159,7 @@ public static <U extends TNumber, T extends TType> DebugNumericsSummary<U> creat
    * @return a new instance of DebugNumericsSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DebugNumericsSummary<TFloat32> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> DebugNumericsSummary<TFloat32> create(Scope scope, Operand<T> input, Options... options) {
     return create(scope, input, TFloat32.DTYPE, options);
   }
   
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 6a3cac82067..56aaf980151 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts each entry in the given tensor to strings.
@@ -116,7 +116,7 @@ private Options() {
    * @return a new instance of AsString
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AsString create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> AsString create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AsString", scope.makeOpName("AsString"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 5acd9c542f6..d73b540c918 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Cast x of type SrcT to y of DstT.
@@ -34,7 +34,7 @@
  * @param <U> data type for {@code y()} output
  */
 @Operator(group = "dtypes")
-public final class Cast<U extends TType> extends RawOp implements Operand<U> {
+public final class Cast<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.dtypes.Cast}
@@ -65,7 +65,7 @@ private Options() {
    * @return a new instance of Cast
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> Cast<U> create(Scope scope, Operand<T> x, DataType<U> DstT, Options... options) {
+  public static <U extends Tensor, T extends Tensor> Cast<U> create(Scope scope, Operand<T> x, DataType<U> DstT, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cast", scope.makeOpName("Cast"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 a342009290f..634b4167b74 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts two real numbers to a complex number.
@@ -50,7 +50,7 @@
  * @param <U> data type for {@code out()} output
  */
 @Operator(group = "dtypes")
-public final class Complex<U extends TType> extends RawOp implements Operand<U> {
+public final class Complex<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Complex operation.
@@ -62,7 +62,7 @@ public final class Complex<U extends TType> extends RawOp implements Operand<U>
    * @return a new instance of Complex
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> Complex<U> create(Scope scope, Operand<T> real, Operand<T> imag, DataType<U> Tout) {
+  public static <U extends Tensor, T extends Tensor & TNumber> Complex<U> create(Scope scope, Operand<T> real, Operand<T> imag, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Complex", scope.makeOpName("Complex"));
     opBuilder.addInput(real.asOutput());
     opBuilder.addInput(imag.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java
index 2130c1279a6..c27a1f57cfc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts a tensor to a scalar predicate.
@@ -54,7 +54,7 @@ public final class ToBool extends RawOp implements Operand<TBool> {
    * @return a new instance of ToBool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ToBool create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> ToBool create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("ToBool", scope.makeOpName("ToBool"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 d297ccebdb2..83525b35fab 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a BoostedTreesEnsembleResource
  */
-public final class BoostedTreesEnsembleResourceHandleOp extends RawOp implements Operand<TType> {
+public final class BoostedTreesEnsembleResourceHandleOp extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesEnsembleResourceHandleOp}
@@ -106,8 +106,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) resource;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) resource;
   }
   
   private Output<?> resource;
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 72898030449..c61b77ebe38 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a BoostedTreesQuantileStreamResource.
  */
-public final class BoostedTreesQuantileStreamResourceHandleOp extends RawOp implements Operand<TType> {
+public final class BoostedTreesQuantileStreamResourceHandleOp extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesQuantileStreamResourceHandleOp}
@@ -106,8 +106,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) resource;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) resource;
   }
   
   private Output<?> resource;
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 acca1abe88b..67e8deb8fef 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adjust the contrast of one or more images.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustContrast<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AdjustContrast<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AdjustContrast operation.
@@ -56,7 +56,7 @@ public final class AdjustContrast<T extends TNumber> extends RawOp implements Op
    * @return a new instance of AdjustContrast
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AdjustContrast<T> create(Scope scope, Operand<T> images, Operand<TFloat32> contrastFactor) {
+  public static <T extends Tensor & TNumber> AdjustContrast<T> create(Scope scope, Operand<T> images, Operand<TFloat32> contrastFactor) {
     OperationBuilder opBuilder = scope.env().opBuilder("AdjustContrastv2", scope.makeOpName("AdjustContrast"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(contrastFactor.asOutput());
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 39d96bec97e..84557ae3c57 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adjust the hue of one or more images.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustHue<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AdjustHue<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AdjustHue operation.
@@ -53,7 +53,7 @@ public final class AdjustHue<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of AdjustHue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AdjustHue<T> create(Scope scope, Operand<T> images, Operand<TFloat32> delta) {
+  public static <T extends Tensor & TNumber> AdjustHue<T> create(Scope scope, Operand<T> images, Operand<TFloat32> delta) {
     OperationBuilder opBuilder = scope.env().opBuilder("AdjustHue", scope.makeOpName("AdjustHue"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(delta.asOutput());
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 3fa15fc4716..5da9470e622 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adjust the saturation of one or more images.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustSaturation<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AdjustSaturation<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AdjustSaturation operation.
@@ -53,7 +53,7 @@ public final class AdjustSaturation<T extends TNumber> extends RawOp implements
    * @return a new instance of AdjustSaturation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AdjustSaturation<T> create(Scope scope, Operand<T> images, Operand<TFloat32> scale) {
+  public static <T extends Tensor & TNumber> AdjustSaturation<T> create(Scope scope, Operand<T> images, Operand<TFloat32> scale) {
     OperationBuilder opBuilder = scope.env().opBuilder("AdjustSaturation", scope.makeOpName("AdjustSaturation"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(scale.asOutput());
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 19c93f95d4b..eee22d1375b 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Extracts crops from the input image tensor and resizes them.
@@ -108,7 +108,7 @@ private Options() {
    * @return a new instance of CropAndResize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CropAndResize create(Scope scope, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> cropSize, Options... options) {
+  public static <T extends Tensor & TNumber> CropAndResize create(Scope scope, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> cropSize, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CropAndResize", scope.makeOpName("CropAndResize"));
     opBuilder.addInput(image.asOutput());
     opBuilder.addInput(boxes.asOutput());
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 e29c2a2c159..47eb509c9be 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of the crop_and_resize op wrt the input boxes tensor.
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of CropAndResizeGradBoxes
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CropAndResizeGradBoxes create(Scope scope, Operand<TFloat32> grads, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Options... options) {
+  public static <T extends Tensor & TNumber> CropAndResizeGradBoxes create(Scope scope, Operand<TFloat32> grads, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CropAndResizeGradBoxes", scope.makeOpName("CropAndResizeGradBoxes"));
     opBuilder.addInput(grads.asOutput());
     opBuilder.addInput(image.asOutput());
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 30b7f0b7ddf..c7c953e8b96 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of the crop_and_resize op wrt the input image tensor.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class CropAndResizeGradImage<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CropAndResizeGradImage<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.CropAndResizeGradImage}
@@ -84,7 +84,7 @@ private Options() {
    * @return a new instance of CropAndResizeGradImage
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CropAndResizeGradImage<T> create(Scope scope, Operand<TFloat32> grads, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> imageSize, DataType<T> T, Options... options) {
+  public static <T extends Tensor & TNumber> CropAndResizeGradImage<T> create(Scope scope, Operand<TFloat32> grads, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> imageSize, DataType<T> T, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CropAndResizeGradImage", scope.makeOpName("CropAndResizeGradImage"));
     opBuilder.addInput(grads.asOutput());
     opBuilder.addInput(boxes.asOutput());
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 6ff272fc487..3f73c54a18e 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TString;
 import org.tensorflow.types.TUint8;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Decode a PNG-encoded image to a uint8 or uint16 tensor.
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code image()} output
  */
 @Operator(group = "image")
-public final class DecodePng<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DecodePng<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.DecodePng}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of DecodePng
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DecodePng<T> create(Scope scope, Operand<TString> contents, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor & TNumber> DecodePng<T> create(Scope scope, Operand<TString> contents, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodePng", scope.makeOpName("DecodePng"));
     opBuilder.addInput(contents.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 08d460a2985..ca1ca14ee37 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Draw bounding boxes on a batch of images.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class DrawBoundingBoxes<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DrawBoundingBoxes<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DrawBoundingBoxes operation.
@@ -60,7 +60,7 @@ public final class DrawBoundingBoxes<T extends TNumber> extends RawOp implements
    * @return a new instance of DrawBoundingBoxes
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DrawBoundingBoxes<T> create(Scope scope, Operand<T> images, Operand<TFloat32> boxes, Operand<TFloat32> colors) {
+  public static <T extends Tensor & TNumber> DrawBoundingBoxes<T> create(Scope scope, Operand<T> images, Operand<TFloat32> boxes, Operand<TFloat32> colors) {
     OperationBuilder opBuilder = scope.env().opBuilder("DrawBoundingBoxesV2", scope.makeOpName("DrawBoundingBoxes"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(boxes.asOutput());
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 0d01ff0f6f4..43a53aebfd4 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * PNG-encode an image.
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of EncodePng
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> EncodePng create(Scope scope, Operand<T> image, Options... options) {
+  public static <T extends Tensor & TNumber> EncodePng create(Scope scope, Operand<T> image, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EncodePng", scope.makeOpName("EncodePng"));
     opBuilder.addInput(image.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 59b3af03fbb..fc8f8e1889a 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Extract `patches` from `images` and put them in the "depth" output dimension.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code patches()} output
  */
 @Operator(group = "image")
-public final class ExtractImagePatches<T extends TType> extends RawOp implements Operand<T> {
+public final class ExtractImagePatches<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExtractImagePatches operation.
@@ -54,7 +54,7 @@ public final class ExtractImagePatches<T extends TType> extends RawOp implements
    * @return a new instance of ExtractImagePatches
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ExtractImagePatches<T> create(Scope scope, Operand<T> images, List<Long> ksizes, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends Tensor> ExtractImagePatches<T> create(Scope scope, Operand<T> images, List<Long> ksizes, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExtractImagePatches", scope.makeOpName("ExtractImagePatches"));
     opBuilder.addInput(images.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 3570c3a6dda..dccb442c0b3 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Extract the shape information of a JPEG-encoded image.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code imageShape()} output
  */
 @Operator(group = "image")
-public final class ExtractJpegShape<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ExtractJpegShape<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExtractJpegShape operation.
@@ -51,7 +51,7 @@ public final class ExtractJpegShape<T extends TNumber> extends RawOp implements
    * @return a new instance of ExtractJpegShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ExtractJpegShape<T> create(Scope scope, Operand<TString> contents, DataType<T> outputType) {
+  public static <T extends Tensor & TNumber> ExtractJpegShape<T> create(Scope scope, Operand<TString> contents, DataType<T> outputType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExtractJpegShape", scope.makeOpName("ExtractJpegShape"));
     opBuilder.addInput(contents.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 6a74b96f923..a9abfca91e1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Convert one or more images from HSV to RGB.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class HsvToRgb<T extends TNumber> extends RawOp implements Operand<T> {
+public final class HsvToRgb<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new HsvToRgb operation.
@@ -50,7 +50,7 @@ public final class HsvToRgb<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of HsvToRgb
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> HsvToRgb<T> create(Scope scope, Operand<T> images) {
+  public static <T extends Tensor & TNumber> HsvToRgb<T> create(Scope scope, Operand<T> images) {
     OperationBuilder opBuilder = scope.env().opBuilder("HSVToRGB", scope.makeOpName("HsvToRgb"));
     opBuilder.addInput(images.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java
index 478d41f7943..660b95c5373 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java
@@ -21,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies the given transform to each of the images.
@@ -41,7 +41,7 @@
  * 
  * @param <T> data type for {@code transformedImages()} output
  */
-public final class ImageProjectiveTransformV2<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ImageProjectiveTransformV2<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ImageProjectiveTransformV2}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of ImageProjectiveTransformV2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ImageProjectiveTransformV2<T> create(Scope scope, Operand<T> images, Operand<TFloat32> transforms, Operand<TInt32> outputShape, String interpolation, Options... options) {
+  public static <T extends Tensor & TNumber> ImageProjectiveTransformV2<T> create(Scope scope, Operand<T> images, Operand<TFloat32> transforms, Operand<TInt32> outputShape, String interpolation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ImageProjectiveTransformV2", scope.makeOpName("ImageProjectiveTransformV2"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(transforms.asOutput());
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 ee83c1d3f06..57460359430 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Greedily selects a subset of bounding boxes in descending order of score,
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code selectedScores()} output
  */
 @Operator(group = "image")
-public final class NonMaxSuppression<T extends TNumber> extends RawOp {
+public final class NonMaxSuppression<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.NonMaxSuppression}
@@ -100,7 +100,7 @@ private Options() {
    * @return a new instance of NonMaxSuppression
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> NonMaxSuppression<T> create(Scope scope, Operand<T> boxes, Operand<T> scores, Operand<TInt32> maxOutputSize, Operand<T> iouThreshold, Operand<T> scoreThreshold, Operand<T> softNmsSigma, Options... options) {
+  public static <T extends Tensor & TNumber> NonMaxSuppression<T> create(Scope scope, Operand<T> boxes, Operand<T> scores, Operand<TInt32> maxOutputSize, Operand<T> iouThreshold, Operand<T> scoreThreshold, Operand<T> softNmsSigma, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("NonMaxSuppressionV5", scope.makeOpName("NonMaxSuppression"));
     opBuilder.addInput(boxes.asOutput());
     opBuilder.addInput(scores.asOutput());
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 9903ce2c265..cb2c7aaa8ab 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Resize quantized `images` to `size` using quantized bilinear interpolation.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code resizedImages()} output
  */
 @Operator(group = "image")
-public final class QuantizedResizeBilinear<T extends TType> extends RawOp {
+public final class QuantizedResizeBilinear<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.QuantizedResizeBilinear}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of QuantizedResizeBilinear
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> QuantizedResizeBilinear<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
+  public static <T extends Tensor> QuantizedResizeBilinear<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedResizeBilinear", scope.makeOpName("QuantizedResizeBilinear"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(size.asOutput());
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 855a60036d9..e1c0a48cd81 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Randomly crop `image`.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class RandomCrop<T extends TNumber> extends RawOp implements Operand<T> {
+public final class RandomCrop<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.RandomCrop}
@@ -84,7 +84,7 @@ private Options() {
    * @return a new instance of RandomCrop
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> RandomCrop<T> create(Scope scope, Operand<T> image, Operand<TInt64> size, Options... options) {
+  public static <T extends Tensor & TNumber> RandomCrop<T> create(Scope scope, Operand<T> image, Operand<TInt64> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomCrop", scope.makeOpName("RandomCrop"));
     opBuilder.addInput(image.asOutput());
     opBuilder.addInput(size.asOutput());
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 dd7d7335570..25830bd2b28 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Resize `images` to `size` using area interpolation.
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of ResizeArea
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResizeArea create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends Tensor & TNumber> ResizeArea create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeArea", scope.makeOpName("ResizeArea"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(size.asOutput());
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 23fa5034437..013b594fe44 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Resize `images` to `size` using bicubic interpolation.
@@ -78,7 +78,7 @@ private Options() {
    * @return a new instance of ResizeBicubic
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResizeBicubic create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends Tensor & TNumber> ResizeBicubic create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBicubic", scope.makeOpName("ResizeBicubic"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(size.asOutput());
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 d7cc678f8a4..666da6e857f 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,20 +21,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of bicubic interpolation.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeBicubicGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ResizeBicubicGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBicubicGrad}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of ResizeBicubicGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResizeBicubicGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
+  public static <T extends Tensor & TNumber> ResizeBicubicGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBicubicGrad", scope.makeOpName("ResizeBicubicGrad"));
     opBuilder.addInput(grads.asOutput());
     opBuilder.addInput(originalImage.asOutput());
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 fb01887d6f5..3be74c76b08 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Resize `images` to `size` using bilinear interpolation.
@@ -78,7 +78,7 @@ private Options() {
    * @return a new instance of ResizeBilinear
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResizeBilinear create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends Tensor & TNumber> ResizeBilinear create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBilinear", scope.makeOpName("ResizeBilinear"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(size.asOutput());
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 85fb0ff85e6..f954077c213 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,20 +21,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of bilinear interpolation.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeBilinearGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ResizeBilinearGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBilinearGrad}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of ResizeBilinearGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResizeBilinearGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
+  public static <T extends Tensor & TNumber> ResizeBilinearGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBilinearGrad", scope.makeOpName("ResizeBilinearGrad"));
     opBuilder.addInput(grads.asOutput());
     opBuilder.addInput(originalImage.asOutput());
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 9183dd63544..c7cf19e3d63 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Resize `images` to `size` using nearest neighbor interpolation.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code resizedImages()} output
  */
 @Operator(group = "image")
-public final class ResizeNearestNeighbor<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ResizeNearestNeighbor<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeNearestNeighbor}
@@ -77,7 +77,7 @@ private Options() {
    * @return a new instance of ResizeNearestNeighbor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResizeNearestNeighbor<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends Tensor & TNumber> ResizeNearestNeighbor<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeNearestNeighbor", scope.makeOpName("ResizeNearestNeighbor"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(size.asOutput());
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 c8fb4f704f8..72d13a2ab86 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,20 +21,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of nearest neighbor interpolation.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeNearestNeighborGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ResizeNearestNeighborGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeNearestNeighborGrad}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of ResizeNearestNeighborGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ResizeNearestNeighborGrad<T> create(Scope scope, Operand<T> grads, Operand<TInt32> size, Options... options) {
+  public static <T extends Tensor & TNumber> ResizeNearestNeighborGrad<T> create(Scope scope, Operand<T> grads, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeNearestNeighborGrad", scope.makeOpName("ResizeNearestNeighborGrad"));
     opBuilder.addInput(grads.asOutput());
     opBuilder.addInput(size.asOutput());
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 a0fdcc30ff8..a382ffcac4e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts one or more images from RGB to HSV.
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class RgbToHsv<T extends TNumber> extends RawOp implements Operand<T> {
+public final class RgbToHsv<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RgbToHsv operation.
@@ -64,7 +64,7 @@ public final class RgbToHsv<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of RgbToHsv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> RgbToHsv<T> create(Scope scope, Operand<T> images) {
+  public static <T extends Tensor & TNumber> RgbToHsv<T> create(Scope scope, Operand<T> images) {
     OperationBuilder opBuilder = scope.env().opBuilder("RGBToHSV", scope.makeOpName("RgbToHsv"));
     opBuilder.addInput(images.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 8281880a8b0..1296d783d92 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Generate a single randomly distorted bounding box for an image.
@@ -73,7 +73,7 @@
  * @param <T> data type for {@code begin()} output
  */
 @Operator(group = "image")
-public final class SampleDistortedBoundingBox<T extends TNumber> extends RawOp {
+public final class SampleDistortedBoundingBox<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.SampleDistortedBoundingBox}
@@ -162,7 +162,7 @@ private Options() {
    * @return a new instance of SampleDistortedBoundingBox
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SampleDistortedBoundingBox<T> create(Scope scope, Operand<T> imageSize, Operand<TFloat32> boundingBoxes, Operand<TFloat32> minObjectCovered, Options... options) {
+  public static <T extends Tensor & TNumber> SampleDistortedBoundingBox<T> create(Scope scope, Operand<T> imageSize, Operand<TFloat32> boundingBoxes, Operand<TFloat32> minObjectCovered, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SampleDistortedBoundingBoxV2", scope.makeOpName("SampleDistortedBoundingBox"));
     opBuilder.addInput(imageSize.asOutput());
     opBuilder.addInput(boundingBoxes.asOutput());
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 bd4cc964f2f..78b665ebfd6 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of ScaleAndTranslate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ScaleAndTranslate create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
+  public static <T extends Tensor & TNumber> ScaleAndTranslate create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScaleAndTranslate", scope.makeOpName("ScaleAndTranslate"));
     opBuilder.addInput(images.asOutput());
     opBuilder.addInput(size.asOutput());
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 8ab90449e1f..eba5be1cd67 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
-public final class ScaleAndTranslateGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ScaleAndTranslateGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ScaleAndTranslateGrad}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of ScaleAndTranslateGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ScaleAndTranslateGrad<T> create(Scope scope, Operand<T> grads, Operand<T> originalImage, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
+  public static <T extends Tensor & TNumber> ScaleAndTranslateGrad<T> create(Scope scope, Operand<T> grads, Operand<T> originalImage, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScaleAndTranslateGrad", scope.makeOpName("ScaleAndTranslateGrad"));
     opBuilder.addInput(grads.asOutput());
     opBuilder.addInput(originalImage.asOutput());
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 4825645c0eb..a5dcc779c6e 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
@@ -24,13 +24,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Convert CSV records to tensors. Each column maps to one tensor.
@@ -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 RawOp implements Iterable<Operand<TType>> {
+public final class DecodeCsv extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodeCsv}
@@ -170,7 +170,7 @@ public List<Output<?>> output() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) output.iterator();
   }
   
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 137f69f7015..996b2b66067 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reinterpret the bytes of a string as a vector of numbers.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class DecodePaddedRaw<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DecodePaddedRaw<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodePaddedRaw}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of DecodePaddedRaw
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DecodePaddedRaw<T> create(Scope scope, Operand<TString> inputBytes, Operand<TInt32> fixedLength, DataType<T> outType, Options... options) {
+  public static <T extends Tensor & TNumber> DecodePaddedRaw<T> create(Scope scope, Operand<TString> inputBytes, Operand<TInt32> fixedLength, DataType<T> outType, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodePaddedRaw", scope.makeOpName("DecodePaddedRaw"));
     opBuilder.addInput(inputBytes.asOutput());
     opBuilder.addInput(fixedLength.asOutput());
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 d42e9e79d6c..8ea48640001 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reinterpret the bytes of a string as a vector of numbers.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class DecodeRaw<T extends TType> extends RawOp implements Operand<T> {
+public final class DecodeRaw<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodeRaw}
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of DecodeRaw
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DecodeRaw<T> create(Scope scope, Operand<TString> bytes, DataType<T> outType, Options... options) {
+  public static <T extends Tensor> DecodeRaw<T> create(Scope scope, Operand<TString> bytes, DataType<T> outType, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeRaw", scope.makeOpName("DecodeRaw"));
     opBuilder.addInput(bytes.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1d80fd486df..75138c95b6c 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Deserialize and concatenate `SparseTensors` from a serialized minibatch.
@@ -78,7 +78,7 @@
  * @param <T> data type for {@code sparseValues()} output
  */
 @Operator(group = "io")
-public final class DeserializeManySparse<T extends TType> extends RawOp {
+public final class DeserializeManySparse<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeserializeManySparse operation.
@@ -90,7 +90,7 @@ public final class DeserializeManySparse<T extends TType> extends RawOp {
    * @return a new instance of DeserializeManySparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DeserializeManySparse<T> create(Scope scope, Operand<TString> serializedSparse, DataType<T> dtype) {
+  public static <T extends Tensor> DeserializeManySparse<T> create(Scope scope, Operand<TString> serializedSparse, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeserializeManySparse", scope.makeOpName("DeserializeManySparse"));
     opBuilder.addInput(serializedSparse.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 95c5bfcd712..d9c95edfe7e 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A queue that produces elements in first-in first-out order.
  */
 @Operator(group = "io")
-public final class FifoQueue extends RawOp implements Operand<TType> {
+public final class FifoQueue extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.FifoQueue}
@@ -171,8 +171,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 a091f665ba4..6de633b08bf 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs fixed-length records from a file.
  */
 @Operator(group = "io")
-public final class FixedLengthRecordReader extends RawOp implements Operand<TType> {
+public final class FixedLengthRecordReader extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.FixedLengthRecordReader}
@@ -194,8 +194,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) readerHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 af9a6ca34e7..dd0b8f15173 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the queued work as both the key and value.
@@ -34,7 +34,7 @@
  * work string and output (work, work).
  */
 @Operator(group = "io")
-public final class IdentityReader extends RawOp implements Operand<TType> {
+public final class IdentityReader extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.IdentityReader}
@@ -115,8 +115,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) readerHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 516ac396ad7..2fe56f42f27 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A queue that produces elements in first-in first-out order.
@@ -38,7 +38,7 @@
  * size of any given element in the minibatch.  See below for details.
  */
 @Operator(group = "io")
-public final class PaddingFifoQueue extends RawOp implements Operand<TType> {
+public final class PaddingFifoQueue extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.PaddingFifoQueue}
@@ -183,8 +183,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 bf2a8e62c2d..9f209cc8b24 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Transforms a serialized tensorflow.TensorProto proto into a Tensor.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class ParseTensor<T extends TType> extends RawOp implements Operand<T> {
+public final class ParseTensor<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ParseTensor operation.
@@ -47,7 +47,7 @@ public final class ParseTensor<T extends TType> extends RawOp implements Operand
    * @return a new instance of ParseTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ParseTensor<T> create(Scope scope, Operand<TString> serialized, DataType<T> outType) {
+  public static <T extends Tensor> ParseTensor<T> create(Scope scope, Operand<TString> serialized, DataType<T> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParseTensor", scope.makeOpName("ParseTensor"));
     opBuilder.addInput(serialized.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 587994bba0f..2ce7d5b0d34 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A queue that produces elements sorted by the first component value.
@@ -40,7 +40,7 @@
  * entry in their input (resp. output) lists.
  */
 @Operator(group = "io")
-public final class PriorityQueue extends RawOp implements Operand<TType> {
+public final class PriorityQueue extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.PriorityQueue}
@@ -157,8 +157,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 d5c2f67db77..2ac307329d7 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,11 +25,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Dequeues a tuple of one or more tensors from the given queue.
@@ -42,7 +42,7 @@
  * has been dequeued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueDequeue extends RawOp implements Iterable<Operand<TType>> {
+public final class QueueDequeue extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeue}
@@ -112,7 +112,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 f705e660c1b..de03edb04a7 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Dequeues `n` tuples of one or more tensors from the given queue.
@@ -50,7 +50,7 @@
  * have been dequeued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueDequeueMany extends RawOp implements Iterable<Operand<TType>> {
+public final class QueueDequeueMany extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeueMany}
@@ -122,7 +122,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 cd1406318ef..1f6bb9cf610 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Dequeues `n` tuples of one or more tensors from the given queue.
@@ -54,7 +54,7 @@
  * component of the dequeued tuple.
  */
 @Operator(group = "io")
-public final class QueueDequeueUpTo extends RawOp implements Iterable<Operand<TType>> {
+public final class QueueDequeueUpTo extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeueUpTo}
@@ -126,7 +126,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 ced52fc58cd..9b4fce26285 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A queue that randomizes the order of elements.
  */
 @Operator(group = "io")
-public final class RandomShuffleQueue extends RawOp implements Operand<TType> {
+public final class RandomShuffleQueue extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.RandomShuffleQueue}
@@ -234,8 +234,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 5cb65e873cc..bad0d043f1a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
@@ -44,7 +44,7 @@
  * @param <U> data type for {@code serializedSparse()} output
  */
 @Operator(group = "io")
-public final class SerializeManySparse<U extends TType> extends RawOp implements Operand<U> {
+public final class SerializeManySparse<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new SerializeManySparse operation.
@@ -58,7 +58,7 @@ public final class SerializeManySparse<U extends TType> extends RawOp implements
    * @return a new instance of SerializeManySparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> SerializeManySparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> SerializeManySparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("SerializeManySparse", scope.makeOpName("SerializeManySparse"));
     opBuilder.addInput(sparseIndices.asOutput());
     opBuilder.addInput(sparseValues.asOutput());
@@ -78,7 +78,7 @@ public static <U extends TType, T extends TType> SerializeManySparse<U> create(S
    * @return a new instance of SerializeManySparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SerializeManySparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
+  public static <T extends Tensor> SerializeManySparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return create(scope, sparseIndices, sparseValues, sparseShape, TString.DTYPE);
   }
   
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 d97317b00d4..41ae4f8f460 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Serialize a `SparseTensor` into a `[3]` `Tensor` object.
@@ -36,7 +36,7 @@
  * @param <U> data type for {@code serializedSparse()} output
  */
 @Operator(group = "io")
-public final class SerializeSparse<U extends TType> extends RawOp implements Operand<U> {
+public final class SerializeSparse<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new SerializeSparse operation.
@@ -50,7 +50,7 @@ public final class SerializeSparse<U extends TType> extends RawOp implements Ope
    * @return a new instance of SerializeSparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> SerializeSparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> SerializeSparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("SerializeSparse", scope.makeOpName("SerializeSparse"));
     opBuilder.addInput(sparseIndices.asOutput());
     opBuilder.addInput(sparseValues.asOutput());
@@ -70,7 +70,7 @@ public static <U extends TType, T extends TType> SerializeSparse<U> create(Scope
    * @return a new instance of SerializeSparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SerializeSparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
+  public static <T extends Tensor> SerializeSparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return create(scope, sparseIndices, sparseValues, sparseShape, TString.DTYPE);
   }
   
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 07935a57d3f..3c2baf1c2ac 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Transforms a Tensor into a serialized TensorProto proto.
@@ -42,7 +42,7 @@ public final class SerializeTensor extends RawOp implements Operand<TString> {
    * @return a new instance of SerializeTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SerializeTensor create(Scope scope, Operand<T> tensor) {
+  public static <T extends Tensor> SerializeTensor create(Scope scope, Operand<T> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("SerializeTensor", scope.makeOpName("SerializeTensor"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 963710a3708..4e1afc17621 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the lines of a file delimited by '\n'.
  */
 @Operator(group = "io")
-public final class TextLineReader extends RawOp implements Operand<TType> {
+public final class TextLineReader extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.TextLineReader}
@@ -131,8 +131,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) readerHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 98d58836334..cf5e15bd576 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the records from a TensorFlow Records file.
  */
 @Operator(group = "io")
-public final class TfRecordReader extends RawOp implements Operand<TType> {
+public final class TfRecordReader extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.TfRecordReader}
@@ -131,8 +131,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) readerHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 444b36aec72..aab3cc7a8aa 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the entire contents of a file as a value.
@@ -34,7 +34,7 @@
  * be a filename (key) and the contents of that file (value).
  */
 @Operator(group = "io")
-public final class WholeFileReader extends RawOp implements Operand<TType> {
+public final class WholeFileReader extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.WholeFileReader}
@@ -115,8 +115,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) readerHandle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 6c4cc2cddba..722dbde298d 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Copy a tensor setting everything outside a central band in each innermost matrix
@@ -72,7 +72,7 @@
  * @param <T> data type for {@code band()} output
  */
 @Operator(group = "linalg")
-public final class BandPart<T extends TType> extends RawOp implements Operand<T> {
+public final class BandPart<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BandPart operation.
@@ -86,7 +86,7 @@ public final class BandPart<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of BandPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> BandPart<T> create(Scope scope, Operand<T> input, Operand<U> numLower, Operand<U> numUpper) {
+  public static <T extends Tensor, U extends Tensor & TNumber> BandPart<T> create(Scope scope, Operand<T> input, Operand<U> numLower, Operand<U> numUpper) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixBandPart", scope.makeOpName("BandPart"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(numLower.asOutput());
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 988d5a23c7f..f9c8cce0604 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchCholesky<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BatchCholesky<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchCholesky operation.
@@ -42,7 +42,7 @@ public final class BatchCholesky<T extends TNumber> extends RawOp implements Ope
    * @return a new instance of BatchCholesky
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BatchCholesky<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor & TNumber> BatchCholesky<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchCholesky", scope.makeOpName("BatchCholesky"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 71b533674a8..26281390006 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchCholeskyGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BatchCholeskyGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchCholeskyGrad operation.
@@ -43,7 +43,7 @@ public final class BatchCholeskyGrad<T extends TNumber> extends RawOp implements
    * @return a new instance of BatchCholeskyGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BatchCholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
+  public static <T extends Tensor & TNumber> BatchCholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchCholeskyGrad", scope.makeOpName("BatchCholeskyGrad"));
     opBuilder.addInput(l.asOutput());
     opBuilder.addInput(grad.asOutput());
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 7b0a946e593..aee9afb96b0 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code band()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixBandPart<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchMatrixBandPart<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixBandPart operation.
@@ -44,7 +44,7 @@ public final class BatchMatrixBandPart<T extends TType> extends RawOp implements
    * @return a new instance of BatchMatrixBandPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchMatrixBandPart<T> create(Scope scope, Operand<T> input, Operand<TInt64> numLower, Operand<TInt64> numUpper) {
+  public static <T extends Tensor> BatchMatrixBandPart<T> create(Scope scope, Operand<T> input, Operand<TInt64> numLower, Operand<TInt64> numUpper) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixBandPart", scope.makeOpName("BatchMatrixBandPart"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(numLower.asOutput());
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 c56dcebd836..57817049d70 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDeterminant<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchMatrixDeterminant<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixDeterminant operation.
@@ -41,7 +41,7 @@ public final class BatchMatrixDeterminant<T extends TType> extends RawOp impleme
    * @return a new instance of BatchMatrixDeterminant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> BatchMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixDeterminant", scope.makeOpName("BatchMatrixDeterminant"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 3cb73f6e451..c4765b1e656 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDiag<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchMatrixDiag<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixDiag operation.
@@ -41,7 +41,7 @@ public final class BatchMatrixDiag<T extends TType> extends RawOp implements Ope
    * @return a new instance of BatchMatrixDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchMatrixDiag<T> create(Scope scope, Operand<T> diagonal) {
+  public static <T extends Tensor> BatchMatrixDiag<T> create(Scope scope, Operand<T> diagonal) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixDiag", scope.makeOpName("BatchMatrixDiag"));
     opBuilder.addInput(diagonal.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 99207f83e9c..7776b261f02 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDiagPart<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchMatrixDiagPart<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixDiagPart operation.
@@ -41,7 +41,7 @@ public final class BatchMatrixDiagPart<T extends TType> extends RawOp implements
    * @return a new instance of BatchMatrixDiagPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchMatrixDiagPart<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> BatchMatrixDiagPart<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixDiagPart", scope.makeOpName("BatchMatrixDiagPart"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 bf8ca469f95..df9ae2a0362 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixInverse<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixInverse<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixInverse}
@@ -62,7 +62,7 @@ private Options() {
    * @return a new instance of BatchMatrixInverse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BatchMatrixInverse<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor & TNumber> BatchMatrixInverse<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixInverse", scope.makeOpName("BatchMatrixInverse"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 7f8508edbb0..50fbf0989a8 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSetDiag<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchMatrixSetDiag<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchMatrixSetDiag operation.
@@ -42,7 +42,7 @@ public final class BatchMatrixSetDiag<T extends TType> extends RawOp implements
    * @return a new instance of BatchMatrixSetDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchMatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal) {
+  public static <T extends Tensor> BatchMatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixSetDiag", scope.makeOpName("BatchMatrixSetDiag"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(diagonal.asOutput());
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 a4b086faa3f..ca4bf37d4cc 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSolve<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixSolve<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixSolve}
@@ -63,7 +63,7 @@ private Options() {
    * @return a new instance of BatchMatrixSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BatchMatrixSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends Tensor & TNumber> BatchMatrixSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixSolve", scope.makeOpName("BatchMatrixSolve"));
     opBuilder.addInput(matrix.asOutput());
     opBuilder.addInput(rhs.asOutput());
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 c5a71d9481d..d2794f4c6dd 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSolveLs<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixSolveLs<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixSolveLs}
@@ -65,7 +65,7 @@ private Options() {
    * @return a new instance of BatchMatrixSolveLs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BatchMatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
+  public static <T extends Tensor & TNumber> BatchMatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixSolveLs", scope.makeOpName("BatchMatrixSolveLs"));
     opBuilder.addInput(matrix.asOutput());
     opBuilder.addInput(rhs.asOutput());
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 186d68a8f68..cdd2fd8c4d4 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixTriangularSolve<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixTriangularSolve<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixTriangularSolve}
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of BatchMatrixTriangularSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BatchMatrixTriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends Tensor & TNumber> BatchMatrixTriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixTriangularSolve", scope.makeOpName("BatchMatrixTriangularSolve"));
     opBuilder.addInput(matrix.asOutput());
     opBuilder.addInput(rhs.asOutput());
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 d2c56803f3a..03f156733ca 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class BatchSelfAdjointEig<T extends TNumber> extends RawOp {
+public final class BatchSelfAdjointEig<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchSelfAdjointEig}
@@ -62,7 +62,7 @@ private Options() {
    * @return a new instance of BatchSelfAdjointEig
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BatchSelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor & TNumber> BatchSelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchSelfAdjointEigV2", scope.makeOpName("BatchSelfAdjointEig"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 25b8da69ab5..a74bfc00872 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "linalg")
-public final class BatchSvd<T extends TType> extends RawOp {
+public final class BatchSvd<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchSvd}
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of BatchSvd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchSvd<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> BatchSvd<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchSvd", scope.makeOpName("BatchSvd"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 64216a5a5d3..bdd1a4bc8d2 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the Cholesky decomposition of one or more square matrices.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Cholesky<T extends TType> extends RawOp implements Operand<T> {
+public final class Cholesky<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cholesky operation.
@@ -57,7 +57,7 @@ public final class Cholesky<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Cholesky
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Cholesky<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Cholesky<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cholesky", scope.makeOpName("Cholesky"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 e60c7eee5fd..bd762dcee34 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the reverse mode backpropagated gradient of the Cholesky algorithm.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class CholeskyGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CholeskyGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CholeskyGrad operation.
@@ -52,7 +52,7 @@ public final class CholeskyGrad<T extends TNumber> extends RawOp implements Oper
    * @return a new instance of CholeskyGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
+  public static <T extends Tensor & TNumber> CholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
     OperationBuilder opBuilder = scope.env().opBuilder("CholeskyGrad", scope.makeOpName("CholeskyGrad"));
     opBuilder.addInput(l.asOutput());
     opBuilder.addInput(grad.asOutput());
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 a1d82fd5d07..50021995578 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Shuffle dimensions of x according to a permutation and conjugate the result.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "linalg")
-public final class ConjugateTranspose<T extends TType> extends RawOp implements Operand<T> {
+public final class ConjugateTranspose<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ConjugateTranspose operation.
@@ -49,7 +49,7 @@ public final class ConjugateTranspose<T extends TType> extends RawOp implements
    * @return a new instance of ConjugateTranspose
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ConjugateTranspose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ConjugateTranspose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConjugateTranspose", scope.makeOpName("ConjugateTranspose"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(perm.asOutput());
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 1de44ceb714..e2fe7c74bff 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the pairwise cross product.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "linalg")
-public final class Cross<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Cross<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cross operation.
@@ -49,7 +49,7 @@ public final class Cross<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Cross
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Cross<T> create(Scope scope, Operand<T> a, Operand<T> b) {
+  public static <T extends Tensor & TNumber> Cross<T> create(Scope scope, Operand<T> a, Operand<T> b) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cross", scope.makeOpName("Cross"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 4ae18c47148..af0f1ac3491 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the determinant of one or more square matrices.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Det<T extends TType> extends RawOp implements Operand<T> {
+public final class Det<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Det operation.
@@ -47,7 +47,7 @@ public final class Det<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Det
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Det<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Det<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDeterminant", scope.makeOpName("Det"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 faaf6dd5972..f0e48f0a671 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of one or more square matrices.
@@ -46,7 +46,7 @@
  * @param <U> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class Eig<U extends TType> extends RawOp {
+public final class Eig<U extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Eig}
@@ -78,7 +78,7 @@ private Options() {
    * @return a new instance of Eig
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> Eig<U> create(Scope scope, Operand<T> input, DataType<U> Tout, Options... options) {
+  public static <U extends Tensor, T extends Tensor> Eig<U> create(Scope scope, Operand<T> input, DataType<U> Tout, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Eig", scope.makeOpName("Eig"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 7471e13882c..5ebba7c28e1 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Tensor contraction according to Einstein summation convention.
@@ -111,7 +111,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Einsum<T extends TType> extends RawOp implements Operand<T> {
+public final class Einsum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Einsum operation.
@@ -122,7 +122,7 @@ public final class Einsum<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Einsum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Einsum<T> create(Scope scope, Iterable<Operand<T>> inputs, String equation) {
+  public static <T extends Tensor> Einsum<T> create(Scope scope, Iterable<Operand<T>> inputs, String equation) {
     OperationBuilder opBuilder = scope.env().opBuilder("Einsum", scope.makeOpName("Einsum"));
     opBuilder.addInputList(Operands.asOutputs(inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 eeb65943fa3..512530ed3c2 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the euclidean norm of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class EuclideanNorm<T extends TType> extends RawOp implements Operand<T> {
+public final class EuclideanNorm<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.EuclideanNorm}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of EuclideanNorm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> EuclideanNorm<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> EuclideanNorm<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EuclideanNorm", scope.makeOpName("EuclideanNorm"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 46fbed05b63..46ac559d61b 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the inverse of one or more square invertible matrices or their
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Inv<T extends TType> extends RawOp implements Operand<T> {
+public final class Inv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Inv}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of Inv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Inv<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> Inv<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixInverse", scope.makeOpName("Inv"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 a19e1753007..4afe18f5406 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sign and the log of the absolute value of the determinant of
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code sign()} output
  */
 @Operator(group = "linalg")
-public final class LogMatrixDeterminant<T extends TType> extends RawOp {
+public final class LogMatrixDeterminant<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LogMatrixDeterminant operation.
@@ -53,7 +53,7 @@ public final class LogMatrixDeterminant<T extends TType> extends RawOp {
    * @return a new instance of LogMatrixDeterminant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> LogMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> LogMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogMatrixDeterminant", scope.makeOpName("LogMatrixDeterminant"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 f243cc902c9..85440bfeadb 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the LU decomposition of one or more square matrices.
@@ -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 RawOp {
+public final class Lu<T extends Tensor, U extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Lu operation.
@@ -67,7 +67,7 @@ public final class Lu<T extends TType, U extends TNumber> extends RawOp {
    * @return a new instance of Lu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Lu<T, U> create(Scope scope, Operand<T> input, DataType<U> outputIdxType) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Lu<T, U> create(Scope scope, Operand<T> input, DataType<U> outputIdxType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Lu", scope.makeOpName("Lu"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -84,7 +84,7 @@ public static <T extends TType, U extends TNumber> Lu<T, U> create(Scope scope,
    * @return a new instance of Lu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Lu<T, TInt32> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Lu<T, TInt32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
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 72466aaceea..777a2337f07 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Multiply the matrix "a" by the matrix "b".
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "linalg")
-public final class MatMul<T extends TType> extends RawOp implements Operand<T> {
+public final class MatMul<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatMul}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of MatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatMul<T> create(Scope scope, Operand<T> a, Operand<T> b, Options... options) {
+  public static <T extends Tensor> MatMul<T> create(Scope scope, Operand<T> a, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatMul", scope.makeOpName("MatMul"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 97e885f95e8..9b53396c643 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a batched diagonal tensor with given batched diagonal values.
@@ -119,7 +119,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiag<T extends TType> extends RawOp implements Operand<T> {
+public final class MatrixDiag<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MatrixDiag operation.
@@ -141,7 +141,7 @@ public final class MatrixDiag<T extends TType> extends RawOp implements Operand<
    * @return a new instance of MatrixDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatrixDiag<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue) {
+  public static <T extends Tensor> MatrixDiag<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagV2", scope.makeOpName("MatrixDiag"));
     opBuilder.addInput(diagonal.asOutput());
     opBuilder.addInput(k.asOutput());
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 81a80bb0d5c..7fcdedee707 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the batched diagonal part of a batched tensor.
@@ -101,7 +101,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiagPart<T extends TType> extends RawOp implements Operand<T> {
+public final class MatrixDiagPart<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MatrixDiagPart operation.
@@ -117,7 +117,7 @@ public final class MatrixDiagPart<T extends TType> extends RawOp implements Oper
    * @return a new instance of MatrixDiagPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatrixDiagPart<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue) {
+  public static <T extends Tensor> MatrixDiagPart<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagPartV2", scope.makeOpName("MatrixDiagPart"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(k.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java
index d4c9adcf553..77c76cea5bb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the batched diagonal part of a batched tensor.
@@ -132,7 +132,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiagPartV3<T extends TType> extends RawOp implements Operand<T> {
+public final class MatrixDiagPartV3<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixDiagPartV3}
@@ -174,7 +174,7 @@ private Options() {
    * @return a new instance of MatrixDiagPartV3
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatrixDiagPartV3<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue, Options... options) {
+  public static <T extends Tensor> MatrixDiagPartV3<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagPartV3", scope.makeOpName("MatrixDiagPartV3"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(k.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java
index ef16e3195da..861955e4d32 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a batched diagonal tensor with given batched diagonal values.
@@ -148,7 +148,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiagV3<T extends TType> extends RawOp implements Operand<T> {
+public final class MatrixDiagV3<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixDiagV3}
@@ -196,7 +196,7 @@ private Options() {
    * @return a new instance of MatrixDiagV3
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatrixDiagV3<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue, Options... options) {
+  public static <T extends Tensor> MatrixDiagV3<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagV3", scope.makeOpName("MatrixDiagV3"));
     opBuilder.addInput(diagonal.asOutput());
     opBuilder.addInput(k.asOutput());
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 ba6adbaf0aa..d70127b110c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the matrix logarithm of one or more square matrices:
@@ -48,7 +48,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MatrixLogarithm<T extends TType> extends RawOp implements Operand<T> {
+public final class MatrixLogarithm<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MatrixLogarithm operation.
@@ -58,7 +58,7 @@ public final class MatrixLogarithm<T extends TType> extends RawOp implements Ope
    * @return a new instance of MatrixLogarithm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatrixLogarithm<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> MatrixLogarithm<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixLogarithm", scope.makeOpName("MatrixLogarithm"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 fe7c7b42d35..e0e390da25c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a batched matrix tensor with new batched diagonal values.
@@ -136,7 +136,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixSetDiag<T extends TType> extends RawOp implements Operand<T> {
+public final class MatrixSetDiag<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixSetDiag}
@@ -178,7 +178,7 @@ private Options() {
    * @return a new instance of MatrixSetDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal, Operand<TInt32> k, Options... options) {
+  public static <T extends Tensor> MatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal, Operand<TInt32> k, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSetDiagV3", scope.makeOpName("MatrixSetDiag"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(diagonal.asOutput());
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 3ed8ddf95d3..8a52a345bcb 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Solves one or more linear least-squares problems.
@@ -69,7 +69,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixSolveLs<T extends TType> extends RawOp implements Operand<T> {
+public final class MatrixSolveLs<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixSolveLs}
@@ -105,7 +105,7 @@ private Options() {
    * @return a new instance of MatrixSolveLs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
+  public static <T extends Tensor> MatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSolveLs", scope.makeOpName("MatrixSolveLs"));
     opBuilder.addInput(matrix.asOutput());
     opBuilder.addInput(rhs.asOutput());
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 e35661a5ae4..9eaa3fa01e1 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the QR decompositions of one or more matrices.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code q()} output
  */
 @Operator(group = "linalg")
-public final class Qr<T extends TType> extends RawOp {
+public final class Qr<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Qr}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of Qr
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Qr<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> Qr<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Qr", scope.makeOpName("Qr"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 749ba329ea1..d6b08f0184e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Perform a quantized matrix multiplication of  `a` by the matrix `b`.
@@ -40,7 +40,7 @@
  * @param <V> data type for {@code out()} output
  */
 @Operator(group = "linalg")
-public final class QuantizedMatMul<V extends TType> extends RawOp {
+public final class QuantizedMatMul<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMul}
@@ -87,7 +87,7 @@ private Options() {
    * @return a new instance of QuantizedMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType, W extends TType> QuantizedMatMul<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, DataType<W> Tactivation, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor, W extends Tensor> QuantizedMatMul<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, DataType<W> Tactivation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMul", scope.makeOpName("QuantizedMatMul"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 48ac255e7a5..9fb6eb388e8 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs a quantized matrix multiplication of `a` by the matrix `b` with bias
@@ -41,7 +41,7 @@
  * 
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBias<W extends TType> extends RawOp {
+public final class QuantizedMatMulWithBias<W extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBias}
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBias
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBias<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<W> Toutput, Options... options) {
+  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBias<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBias", scope.makeOpName("QuantizedMatMulWithBias"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 6958b14a7f3..c6222beb77e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Perform a quantized matrix multiplication of  `a` by the matrix `b` with bias
@@ -42,7 +42,7 @@
  * 
  * @param <V> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndRelu<V extends TType> extends RawOp {
+public final class QuantizedMatMulWithBiasAndRelu<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBiasAndRelu}
@@ -98,7 +98,7 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedMatMulWithBiasAndRelu<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedMatMulWithBiasAndRelu<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndRelu", scope.makeOpName("QuantizedMatMulWithBiasAndRelu"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 17d2b2a25d0..a5080d093a3 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Perform a quantized matrix multiplication of  `a` by the matrix `b` with bias
@@ -43,7 +43,7 @@
  * 
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
+public final class QuantizedMatMulWithBiasAndReluAndRequantize<W extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBiasAndReluAndRequantize}
@@ -101,7 +101,7 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
+  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndReluAndRequantize", scope.makeOpName("QuantizedMatMulWithBiasAndReluAndRequantize"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 d0d3e8f4f5f..4257b52df16 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of one or more square self-adjoint matrices.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class SelfAdjointEig<T extends TType> extends RawOp {
+public final class SelfAdjointEig<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.SelfAdjointEig}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of SelfAdjointEig
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> SelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SelfAdjointEigV2", scope.makeOpName("SelfAdjointEig"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 087b8ef7991..6add924f912 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Solves systems of linear equations.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Solve<T extends TType> extends RawOp implements Operand<T> {
+public final class Solve<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Solve}
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of Solve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Solve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends Tensor> Solve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSolve", scope.makeOpName("Solve"));
     opBuilder.addInput(matrix.asOutput());
     opBuilder.addInput(rhs.asOutput());
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 86d747a81a5..b628c847316 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the matrix square root of one or more square matrices:
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Sqrtm<T extends TType> extends RawOp implements Operand<T> {
+public final class Sqrtm<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sqrtm operation.
@@ -59,7 +59,7 @@ public final class Sqrtm<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Sqrtm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sqrtm<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Sqrtm<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSquareRoot", scope.makeOpName("Sqrtm"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 df0772367fd..02570b12a65 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the singular value decompositions of one or more matrices.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "linalg")
-public final class Svd<T extends TType> extends RawOp {
+public final class Svd<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Svd}
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of Svd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Svd<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> Svd<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Svd", scope.makeOpName("Svd"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 40bf987f815..10ef41e2b04 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a diagonal tensor with a given diagonal values.
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class TensorDiag<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorDiag<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorDiag operation.
@@ -61,7 +61,7 @@ public final class TensorDiag<T extends TType> extends RawOp implements Operand<
    * @return a new instance of TensorDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorDiag<T> create(Scope scope, Operand<T> diagonal) {
+  public static <T extends Tensor> TensorDiag<T> create(Scope scope, Operand<T> diagonal) {
     OperationBuilder opBuilder = scope.env().opBuilder("Diag", scope.makeOpName("TensorDiag"));
     opBuilder.addInput(diagonal.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c14b82af064..825a182d290 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the diagonal part of the tensor.
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class TensorDiagPart<T extends TType> extends RawOp implements Operand<T> {
+public final class TensorDiagPart<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TensorDiagPart operation.
@@ -62,7 +62,7 @@ public final class TensorDiagPart<T extends TType> extends RawOp implements Oper
    * @return a new instance of TensorDiagPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorDiagPart<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> TensorDiagPart<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("DiagPart", scope.makeOpName("TensorDiagPart"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 5ce582563ea..2e9818da3dd 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Shuffle dimensions of x according to a permutation.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "linalg")
-public final class Transpose<T extends TType> extends RawOp implements Operand<T> {
+public final class Transpose<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Transpose operation.
@@ -48,7 +48,7 @@ public final class Transpose<T extends TType> extends RawOp implements Operand<T
    * @return a new instance of Transpose
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Transpose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Transpose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
     OperationBuilder opBuilder = scope.env().opBuilder("Transpose", scope.makeOpName("Transpose"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(perm.asOutput());
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 ba5ce4f65c2..bba2206dc79 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Solves systems of linear equations with upper or lower triangular matrices by backsubstitution.
@@ -80,7 +80,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class TriangularSolve<T extends TType> extends RawOp implements Operand<T> {
+public final class TriangularSolve<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.TriangularSolve}
@@ -126,7 +126,7 @@ private Options() {
    * @return a new instance of TriangularSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends Tensor> TriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixTriangularSolve", scope.makeOpName("TriangularSolve"));
     opBuilder.addInput(matrix.asOutput());
     opBuilder.addInput(rhs.asOutput());
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 7fb782724f9..4ba3843728a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Calculate product with tridiagonal matrix.
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TridiagonalMatMul<T extends TType> extends RawOp implements Operand<T> {
+public final class TridiagonalMatMul<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TridiagonalMatMul operation.
@@ -51,7 +51,7 @@ public final class TridiagonalMatMul<T extends TType> extends RawOp implements O
    * @return a new instance of TridiagonalMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TridiagonalMatMul<T> create(Scope scope, Operand<T> superdiag, Operand<T> maindiag, Operand<T> subdiag, Operand<T> rhs) {
+  public static <T extends Tensor> TridiagonalMatMul<T> create(Scope scope, Operand<T> superdiag, Operand<T> maindiag, Operand<T> subdiag, Operand<T> rhs) {
     OperationBuilder opBuilder = scope.env().opBuilder("TridiagonalMatMul", scope.makeOpName("TridiagonalMatMul"));
     opBuilder.addInput(superdiag.asOutput());
     opBuilder.addInput(maindiag.asOutput());
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 0ad614e24d2..10d4a588f20 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Solves tridiagonal systems of equations.
@@ -39,7 +39,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TridiagonalSolve<T extends TType> extends RawOp implements Operand<T> {
+public final class TridiagonalSolve<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.TridiagonalSolve}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of TridiagonalSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TridiagonalSolve<T> create(Scope scope, Operand<T> diagonals, Operand<T> rhs, Options... options) {
+  public static <T extends Tensor> TridiagonalSolve<T> create(Scope scope, Operand<T> diagonals, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TridiagonalSolve", scope.makeOpName("TridiagonalSolve"));
     opBuilder.addInput(diagonals.asOutput());
     opBuilder.addInput(rhs.asOutput());
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 01e7c156baf..210c051483d 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reads out the CSR components at batch `index`.
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code values()} output
  */
-public final class CSRSparseMatrixComponents<T extends TType> extends RawOp {
+public final class CSRSparseMatrixComponents<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixComponents operation.
@@ -49,7 +49,7 @@ public final class CSRSparseMatrixComponents<T extends TType> extends RawOp {
    * @return a new instance of CSRSparseMatrixComponents
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> CSRSparseMatrixComponents<T> create(Scope scope, Operand<?> csrSparseMatrix, Operand<TInt32> index, DataType<T> type) {
+  public static <T extends Tensor> CSRSparseMatrixComponents<T> create(Scope scope, Operand<?> csrSparseMatrix, Operand<TInt32> index, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("CSRSparseMatrixComponents", scope.makeOpName("CSRSparseMatrixComponents"));
     opBuilder.addInput(csrSparseMatrix.asOutput());
     opBuilder.addInput(index.asOutput());
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 f221c56fce1..4f9751b6b0e 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Convert a (possibly batched) CSRSparseMatrix to dense.
  * 
  * @param <T> data type for {@code denseOutput()} output
  */
-public final class CSRSparseMatrixToDense<T extends TType> extends RawOp implements Operand<T> {
+public final class CSRSparseMatrixToDense<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixToDense operation.
@@ -44,7 +44,7 @@ public final class CSRSparseMatrixToDense<T extends TType> extends RawOp impleme
    * @return a new instance of CSRSparseMatrixToDense
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> CSRSparseMatrixToDense<T> create(Scope scope, Operand<?> sparseInput, DataType<T> type) {
+  public static <T extends Tensor> CSRSparseMatrixToDense<T> create(Scope scope, Operand<?> sparseInput, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("CSRSparseMatrixToDense", scope.makeOpName("CSRSparseMatrixToDense"));
     opBuilder.addInput(sparseInput.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c9796bf7573..d66d4412490 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts a (possibly batched) CSRSparesMatrix to a SparseTensor.
  * 
  * @param <T> data type for {@code values()} output
  */
-public final class CSRSparseMatrixToSparseTensor<T extends TType> extends RawOp {
+public final class CSRSparseMatrixToSparseTensor<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixToSparseTensor operation.
@@ -45,7 +45,7 @@ public final class CSRSparseMatrixToSparseTensor<T extends TType> extends RawOp
    * @return a new instance of CSRSparseMatrixToSparseTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> CSRSparseMatrixToSparseTensor<T> create(Scope scope, Operand<?> sparseMatrix, DataType<T> type) {
+  public static <T extends Tensor> CSRSparseMatrixToSparseTensor<T> create(Scope scope, Operand<?> sparseMatrix, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("CSRSparseMatrixToSparseTensor", scope.makeOpName("CSRSparseMatrixToSparseTensor"));
     opBuilder.addInput(sparseMatrix.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 93414b7e7f6..c8bda5f9212 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts a dense tensor to a (possibly batched) CSRSparseMatrix.
  */
-public final class DenseToCSRSparseMatrix extends RawOp implements Operand<TType> {
+public final class DenseToCSRSparseMatrix extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new DenseToCSRSparseMatrix operation.
@@ -42,7 +42,7 @@ public final class DenseToCSRSparseMatrix extends RawOp implements Operand<TType
    * @return a new instance of DenseToCSRSparseMatrix
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DenseToCSRSparseMatrix create(Scope scope, Operand<T> denseInput, Operand<TInt64> indices) {
+  public static <T extends Tensor> DenseToCSRSparseMatrix create(Scope scope, Operand<T> denseInput, Operand<TInt64> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("DenseToCSRSparseMatrix", scope.makeOpName("DenseToCSRSparseMatrix"));
     opBuilder.addInput(denseInput.asOutput());
     opBuilder.addInput(indices.asOutput());
@@ -59,8 +59,8 @@ public Output<?> sparseOutput() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) sparseOutput;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) sparseOutput;
   }
   
   private Output<?> sparseOutput;
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 2e7b03b0fb6..47179a5c9ce 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sparse addition of two CSR matrices, C = alpha * A + beta * B.
@@ -33,7 +33,7 @@
  * The gradients of SparseMatrixAdd outputs with respect to alpha and beta are not
  * currently defined (TensorFlow will return zeros for these entries).
  */
-public final class SparseMatrixAdd extends RawOp implements Operand<TType> {
+public final class SparseMatrixAdd extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixAdd operation.
@@ -46,7 +46,7 @@ public final class SparseMatrixAdd extends RawOp implements Operand<TType> {
    * @return a new instance of SparseMatrixAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseMatrixAdd create(Scope scope, Operand<?> a, Operand<?> b, Operand<T> alpha, Operand<T> beta) {
+  public static <T extends Tensor> SparseMatrixAdd create(Scope scope, Operand<?> a, Operand<?> b, Operand<T> alpha, Operand<T> beta) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixAdd", scope.makeOpName("SparseMatrixAdd"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
@@ -65,8 +65,8 @@ public Output<?> c() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) c;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) c;
   }
   
   private Output<?> c;
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 999afbb7a1a..00ef65841d7 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Matrix-multiplies a sparse matrix with a dense matrix.
@@ -57,7 +57,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class SparseMatrixMatMul<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseMatrixMatMul<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixMatMul}
@@ -133,7 +133,7 @@ private Options() {
    * @return a new instance of SparseMatrixMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseMatrixMatMul<T> create(Scope scope, Operand<?> a, Operand<T> b, Options... options) {
+  public static <T extends Tensor> SparseMatrixMatMul<T> create(Scope scope, Operand<?> a, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixMatMul", scope.makeOpName("SparseMatrixMatMul"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 cc6f936e661..dc0167402b7 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Element-wise multiplication of a sparse matrix with a dense tensor.
@@ -39,7 +39,7 @@
  * <b>NOTE</b> even if `b` is zero, the sparsity structure of the output does not
  * change.
  */
-public final class SparseMatrixMul extends RawOp implements Operand<TType> {
+public final class SparseMatrixMul extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixMul operation.
@@ -50,7 +50,7 @@ public final class SparseMatrixMul extends RawOp implements Operand<TType> {
    * @return a new instance of SparseMatrixMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseMatrixMul create(Scope scope, Operand<?> a, Operand<T> b) {
+  public static <T extends Tensor> SparseMatrixMul create(Scope scope, Operand<?> a, Operand<T> b) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixMul", scope.makeOpName("SparseMatrixMul"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
@@ -67,8 +67,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 2d62bbb6899..29d1b3cbe2c 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Calculates the softmax of a CSRSparseMatrix.
@@ -38,7 +38,7 @@
  * the output has the same sparsity structure as the input (though missing values
  * in the output may now be treated as having probability zero).
  */
-public final class SparseMatrixSoftmax extends RawOp implements Operand<TType> {
+public final class SparseMatrixSoftmax extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSoftmax operation.
@@ -49,7 +49,7 @@ public final class SparseMatrixSoftmax extends RawOp implements Operand<TType> {
    * @return a new instance of SparseMatrixSoftmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SparseMatrixSoftmax create(Scope scope, Operand<?> logits, DataType<T> type) {
+  public static <T extends Tensor & TNumber> SparseMatrixSoftmax create(Scope scope, Operand<?> logits, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSoftmax", scope.makeOpName("SparseMatrixSoftmax"));
     opBuilder.addInput(logits.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -66,8 +66,8 @@ public Output<?> softmax() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) softmax;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) softmax;
   }
   
   private Output<?> softmax;
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 0a698bb7929..0e5c5d62a14 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,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Calculates the gradient of the SparseMatrixSoftmax op.
  */
-public final class SparseMatrixSoftmaxGrad extends RawOp implements Operand<TType> {
+public final class SparseMatrixSoftmaxGrad extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSoftmaxGrad operation.
@@ -44,7 +44,7 @@ public final class SparseMatrixSoftmaxGrad extends RawOp implements Operand<TTyp
    * @return a new instance of SparseMatrixSoftmaxGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SparseMatrixSoftmaxGrad create(Scope scope, Operand<?> softmax, Operand<?> gradSoftmax, DataType<T> type) {
+  public static <T extends Tensor & TNumber> SparseMatrixSoftmaxGrad create(Scope scope, Operand<?> softmax, Operand<?> gradSoftmax, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSoftmaxGrad", scope.makeOpName("SparseMatrixSoftmaxGrad"));
     opBuilder.addInput(softmax.asOutput());
     opBuilder.addInput(gradSoftmax.asOutput());
@@ -62,8 +62,8 @@ public Output<?> gradient() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) gradient;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) gradient;
   }
   
   private Output<?> gradient;
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 603e4e30c9f..3af4a96dc60 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sparse Cholesky decomposition of `input`.
@@ -103,7 +103,7 @@
  * permutation: A `Tensor`.
  * type: The type of `input`.
  */
-public final class SparseMatrixSparseCholesky extends RawOp implements Operand<TType> {
+public final class SparseMatrixSparseCholesky extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSparseCholesky operation.
@@ -115,7 +115,7 @@ public final class SparseMatrixSparseCholesky extends RawOp implements Operand<T
    * @return a new instance of SparseMatrixSparseCholesky
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseMatrixSparseCholesky create(Scope scope, Operand<?> input, Operand<TInt32> permutation, DataType<T> type) {
+  public static <T extends Tensor> SparseMatrixSparseCholesky create(Scope scope, Operand<?> input, Operand<TInt32> permutation, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSparseCholesky", scope.makeOpName("SparseMatrixSparseCholesky"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(permutation.asOutput());
@@ -133,8 +133,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 2e8bafb9b0b..475c378eefa 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sparse-matrix-multiplies two CSR matrices `a` and `b`.
@@ -104,7 +104,7 @@
  * adjoint_a: If True, `a` adjointed before multiplication.
  * adjoint_b: If True, `b` adjointed before multiplication.
  */
-public final class SparseMatrixSparseMatMul extends RawOp implements Operand<TType> {
+public final class SparseMatrixSparseMatMul extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixSparseMatMul}
@@ -163,7 +163,7 @@ private Options() {
    * @return a new instance of SparseMatrixSparseMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseMatrixSparseMatMul create(Scope scope, Operand<?> a, Operand<?> b, DataType<T> type, Options... options) {
+  public static <T extends Tensor> SparseMatrixSparseMatMul create(Scope scope, Operand<?> a, Operand<?> b, DataType<T> type, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSparseMatMul", scope.makeOpName("SparseMatrixSparseMatMul"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
@@ -225,8 +225,8 @@ public Output<?> c() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) c;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) c;
   }
   
   private Output<?> c;
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 6801b45dd6d..01b03a306cf 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Transposes the inner (matrix) dimensions of a CSRSparseMatrix.
@@ -34,7 +34,7 @@
  * Transposes the inner (matrix) dimensions of a SparseMatrix and optionally
  * conjugates its values.
  */
-public final class SparseMatrixTranspose extends RawOp implements Operand<TType> {
+public final class SparseMatrixTranspose extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixTranspose}
@@ -65,7 +65,7 @@ private Options() {
    * @return a new instance of SparseMatrixTranspose
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseMatrixTranspose create(Scope scope, Operand<?> input, DataType<T> type, Options... options) {
+  public static <T extends Tensor> SparseMatrixTranspose create(Scope scope, Operand<?> input, DataType<T> type, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixTranspose", scope.makeOpName("SparseMatrixTranspose"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -96,8 +96,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 eab0d59e8c2..33a074d6a38 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,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates an all-zeros CSRSparseMatrix with shape `dense_shape`.
  */
-public final class SparseMatrixZeros extends RawOp implements Operand<TType> {
+public final class SparseMatrixZeros extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixZeros operation.
@@ -43,7 +43,7 @@ public final class SparseMatrixZeros extends RawOp implements Operand<TType> {
    * @return a new instance of SparseMatrixZeros
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseMatrixZeros create(Scope scope, Operand<TInt64> denseShape, DataType<T> type) {
+  public static <T extends Tensor> SparseMatrixZeros create(Scope scope, Operand<TInt64> denseShape, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixZeros", scope.makeOpName("SparseMatrixZeros"));
     opBuilder.addInput(denseShape.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -60,8 +60,8 @@ public Output<?> sparseMatrix() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) sparseMatrix;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) sparseMatrix;
   }
   
   private Output<?> sparseMatrix;
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 a14a09c9433..0b22684d38c 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts a SparseTensor to a (possibly batched) CSRSparseMatrix.
  */
-public final class SparseTensorToCSRSparseMatrix extends RawOp implements Operand<TType> {
+public final class SparseTensorToCSRSparseMatrix extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorToCSRSparseMatrix operation.
@@ -43,7 +43,7 @@ public final class SparseTensorToCSRSparseMatrix extends RawOp implements Operan
    * @return a new instance of SparseTensorToCSRSparseMatrix
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseTensorToCSRSparseMatrix create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
+  public static <T extends Tensor> SparseTensorToCSRSparseMatrix create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorToCSRSparseMatrix", scope.makeOpName("SparseTensorToCSRSparseMatrix"));
     opBuilder.addInput(indices.asOutput());
     opBuilder.addInput(values.asOutput());
@@ -61,8 +61,8 @@ public Output<?> sparseMatrix() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) sparseMatrix;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) sparseMatrix;
   }
   
   private Output<?> sparseMatrix;
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 a04d249dc74..a297e6dcae0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the absolute value of a tensor.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Abs<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Abs<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Abs operation.
@@ -48,7 +48,7 @@ public final class Abs<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Abs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Abs<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Abs<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Abs", scope.makeOpName("Abs"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 733a7546f57..3c67af8b65b 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the element-wise sum of a list of tensors.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code sum()} output
  */
 @Operator(group = "math")
-public final class AccumulateN<T extends TType> extends RawOp implements Operand<T> {
+public final class AccumulateN<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AccumulateN operation.
@@ -55,7 +55,7 @@ public final class AccumulateN<T extends TType> extends RawOp implements Operand
    * @return a new instance of AccumulateN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AccumulateN<T> create(Scope scope, Iterable<Operand<T>> inputs, Shape shape) {
+  public static <T extends Tensor> AccumulateN<T> create(Scope scope, Iterable<Operand<T>> inputs, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulateNV2", scope.makeOpName("AccumulateN"));
     opBuilder.addInputList(Operands.asOutputs(inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 200fa10daad..1b3102d6005 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes acos of x element-wise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Acos<T extends TType> extends RawOp implements Operand<T> {
+public final class Acos<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Acos operation.
@@ -43,7 +43,7 @@ public final class Acos<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Acos
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Acos<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Acos<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Acos", scope.makeOpName("Acos"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 e26f402b14e..e1c13a90b01 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes inverse hyperbolic cosine of x element-wise.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Acosh<T extends TType> extends RawOp implements Operand<T> {
+public final class Acosh<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Acosh operation.
@@ -51,7 +51,7 @@ public final class Acosh<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Acosh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Acosh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Acosh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Acosh", scope.makeOpName("Acosh"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 2c3c69e735f..25d32e0bb77 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x + y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Add<T extends TType> extends RawOp implements Operand<T> {
+public final class Add<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Add operation.
@@ -47,7 +47,7 @@ public final class Add<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Add
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Add<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Add<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Add", scope.makeOpName("Add"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 aa6abe36421..f5eab8b9c57 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Add all input tensors element wise.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code sum()} output
  */
 @Operator(group = "math")
-public final class AddN<T extends TType> extends RawOp implements Operand<T> {
+public final class AddN<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AddN operation.
@@ -52,7 +52,7 @@ public final class AddN<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of AddN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AddN<T> create(Scope scope, Iterable<Operand<T>> inputs) {
+  public static <T extends Tensor> AddN<T> create(Scope scope, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("AddN", scope.makeOpName("AddN"));
     opBuilder.addInputList(Operands.asOutputs(inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 08c203e2625..14793f50b90 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the argument of a complex number.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Angle<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Angle<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Angle operation.
@@ -63,7 +63,7 @@ public final class Angle<U extends TNumber> extends RawOp implements Operand<U>
    * @return a new instance of Angle
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Angle<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Angle<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Angle", scope.makeOpName("Angle"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -79,7 +79,7 @@ public static <U extends TNumber, T extends TType> Angle<U> create(Scope scope,
    * @return a new instance of Angle
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Angle<TFloat32> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Angle<TFloat32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TFloat32.DTYPE);
   }
   
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 83762aa8117..9cd2d5402f5 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of abs(x-y) < tolerance element-wise.
@@ -63,7 +63,7 @@ private Options() {
    * @return a new instance of ApproximateEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApproximateEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends Tensor> ApproximateEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApproximateEqual", scope.makeOpName("ApproximateEqual"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 9670f62b1a5..49374ebb4f0 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the index with the largest value across dimensions of a tensor.
@@ -49,7 +49,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class ArgMax<V extends TNumber> extends RawOp implements Operand<V> {
+public final class ArgMax<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new ArgMax operation.
@@ -63,7 +63,7 @@ public final class ArgMax<V extends TNumber> extends RawOp implements Operand<V>
    * @return a new instance of ArgMax
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TType, U extends TNumber> ArgMax<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
+  public static <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMax<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ArgMax", scope.makeOpName("ArgMax"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(dimension.asOutput());
@@ -83,7 +83,7 @@ public static <V extends TNumber, T extends TType, U extends TNumber> ArgMax<V>
    * @return a new instance of ArgMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ArgMax<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ArgMax<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
     return create(scope, input, dimension, TInt64.DTYPE);
   }
   
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 00e84ed2dc3..a31a942d01e 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the index with the smallest value across dimensions of a tensor.
@@ -49,7 +49,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class ArgMin<V extends TNumber> extends RawOp implements Operand<V> {
+public final class ArgMin<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new ArgMin operation.
@@ -63,7 +63,7 @@ public final class ArgMin<V extends TNumber> extends RawOp implements Operand<V>
    * @return a new instance of ArgMin
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TType, U extends TNumber> ArgMin<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
+  public static <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMin<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ArgMin", scope.makeOpName("ArgMin"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(dimension.asOutput());
@@ -83,7 +83,7 @@ public static <V extends TNumber, T extends TType, U extends TNumber> ArgMin<V>
    * @return a new instance of ArgMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ArgMin<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ArgMin<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
     return create(scope, input, dimension, TInt64.DTYPE);
   }
   
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 6dd53582f63..efe680b873a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the trignometric inverse sine of x element-wise.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Asin<T extends TType> extends RawOp implements Operand<T> {
+public final class Asin<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Asin operation.
@@ -59,7 +59,7 @@ public final class Asin<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Asin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Asin<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Asin<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Asin", scope.makeOpName("Asin"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 93131b0b597..33cc22dd0b6 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes inverse hyperbolic sine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Asinh<T extends TType> extends RawOp implements Operand<T> {
+public final class Asinh<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Asinh operation.
@@ -53,7 +53,7 @@ public final class Asinh<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Asinh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Asinh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Asinh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Asinh", scope.makeOpName("Asinh"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 ae1c0de475b..0d46418dd5c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the trignometric inverse tangent of x element-wise.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Atan<T extends TType> extends RawOp implements Operand<T> {
+public final class Atan<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Atan operation.
@@ -59,7 +59,7 @@ public final class Atan<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Atan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Atan<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Atan<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Atan", scope.makeOpName("Atan"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 d77090da6a1..0a05b13d990 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes arctangent of `y/x` element-wise, respecting signs of the arguments.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Atan2<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Atan2<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Atan2 operation.
@@ -51,7 +51,7 @@ public final class Atan2<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Atan2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Atan2<T> create(Scope scope, Operand<T> y, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Atan2<T> create(Scope scope, Operand<T> y, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Atan2", scope.makeOpName("Atan2"));
     opBuilder.addInput(y.asOutput());
     opBuilder.addInput(x.asOutput());
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 2d8596be938..aea16a1c015 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes inverse hyperbolic tangent of x element-wise.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Atanh<T extends TType> extends RawOp implements Operand<T> {
+public final class Atanh<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Atanh operation.
@@ -55,7 +55,7 @@ public final class Atanh<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Atanh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Atanh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Atanh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Atanh", scope.makeOpName("Atanh"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 b951b555fc9..267c801fe6b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the Bessel i0e function of `x` element-wise.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class BesselI0e<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BesselI0e<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BesselI0e operation.
@@ -49,7 +49,7 @@ public final class BesselI0e<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of BesselI0e
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BesselI0e<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> BesselI0e<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("BesselI0e", scope.makeOpName("BesselI0e"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 9d92b8a4d66..ca7571067b0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the Bessel i1e function of `x` element-wise.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class BesselI1e<T extends TNumber> extends RawOp implements Operand<T> {
+public final class BesselI1e<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BesselI1e operation.
@@ -49,7 +49,7 @@ public final class BesselI1e<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of BesselI1e
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BesselI1e<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> BesselI1e<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("BesselI1e", scope.makeOpName("BesselI1e"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 bf42fa10faf..597985dd639 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the regularized incomplete beta integral \\(I_x(a, b)\\).
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Betainc<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Betainc<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Betainc operation.
@@ -57,7 +57,7 @@ public final class Betainc<T extends TNumber> extends RawOp implements Operand<T
    * @return a new instance of Betainc
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Betainc<T> create(Scope scope, Operand<T> a, Operand<T> b, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Betainc<T> create(Scope scope, Operand<T> a, Operand<T> b, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Betainc", scope.makeOpName("Betainc"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 30b96bf1b5d..8946584d9e6 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Counts the number of occurrences of each value in an integer array.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code bins()} output
  */
 @Operator(group = "math")
-public final class Bincount<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Bincount<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Bincount operation.
@@ -57,7 +57,7 @@ public final class Bincount<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of Bincount
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Bincount<T> create(Scope scope, Operand<TInt32> arr, Operand<TInt32> size, Operand<T> weights) {
+  public static <T extends Tensor & TNumber> Bincount<T> create(Scope scope, Operand<TInt32> arr, Operand<TInt32> size, Operand<T> weights) {
     OperationBuilder opBuilder = scope.env().opBuilder("Bincount", scope.makeOpName("Bincount"));
     opBuilder.addInput(arr.asOutput());
     opBuilder.addInput(size.asOutput());
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 36bcf7ce417..1aa94156af4 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns element-wise smallest integer not less than x.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Ceil<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Ceil<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ceil operation.
@@ -44,7 +44,7 @@ public final class Ceil<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Ceil
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Ceil<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Ceil<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Ceil", scope.makeOpName("Ceil"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 a00341d467d..8645138dc70 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TUint8;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compare values of `input` to `threshold` and pack resulting bits into a `uint8`.
@@ -65,7 +65,7 @@ public final class CompareAndBitpack extends RawOp implements Operand<TUint8> {
    * @return a new instance of CompareAndBitpack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> CompareAndBitpack create(Scope scope, Operand<T> input, Operand<T> threshold) {
+  public static <T extends Tensor> CompareAndBitpack create(Scope scope, Operand<T> input, Operand<T> threshold) {
     OperationBuilder opBuilder = scope.env().opBuilder("CompareAndBitpack", scope.makeOpName("CompareAndBitpack"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(threshold.asOutput());
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 f72854aa5ed..3e0f1ef5a5a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the complex absolute value of a tensor.
@@ -41,7 +41,7 @@
  * @param <U> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class ComplexAbs<U extends TNumber> extends RawOp implements Operand<U> {
+public final class ComplexAbs<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new ComplexAbs operation.
@@ -52,7 +52,7 @@ public final class ComplexAbs<U extends TNumber> extends RawOp implements Operan
    * @return a new instance of ComplexAbs
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> ComplexAbs<U> create(Scope scope, Operand<T> x, DataType<U> Tout) {
+  public static <U extends Tensor & TNumber, T extends Tensor> ComplexAbs<U> create(Scope scope, Operand<T> x, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("ComplexAbs", scope.makeOpName("ComplexAbs"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -68,7 +68,7 @@ public static <U extends TNumber, T extends TType> ComplexAbs<U> create(Scope sc
    * @return a new instance of ComplexAbs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ComplexAbs<TFloat32> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> ComplexAbs<TFloat32> create(Scope scope, Operand<T> x) {
     return create(scope, x, TFloat32.DTYPE);
   }
   
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 c633957aeb2..68ea9c22be0 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the complex conjugate of a complex number.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Conj<T extends TType> extends RawOp implements Operand<T> {
+public final class Conj<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Conj operation.
@@ -57,7 +57,7 @@ public final class Conj<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Conj
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Conj<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Conj<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conj", scope.makeOpName("Conj"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 8a61ed1db2a..b3c193ac80f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes cos of x element-wise.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Cos<T extends TType> extends RawOp implements Operand<T> {
+public final class Cos<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cos operation.
@@ -54,7 +54,7 @@ public final class Cos<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Cos
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Cos<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Cos<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cos", scope.makeOpName("Cos"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 20f70fe2f0c..6da422436ac 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes hyperbolic cosine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Cosh<T extends TType> extends RawOp implements Operand<T> {
+public final class Cosh<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Cosh operation.
@@ -53,7 +53,7 @@ public final class Cosh<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Cosh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Cosh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Cosh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cosh", scope.makeOpName("Cosh"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 faab91b5bd9..3e2e807bce0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the cumulative product of the tensor `x` along `axis`.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "math")
-public final class Cumprod<T extends TType> extends RawOp implements Operand<T> {
+public final class Cumprod<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Cumprod}
@@ -100,7 +100,7 @@ private Options() {
    * @return a new instance of Cumprod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Cumprod<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Cumprod<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cumprod", scope.makeOpName("Cumprod"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(axis.asOutput());
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 a1027a8b221..18609d5d886 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the cumulative sum of the tensor `x` along `axis`.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "math")
-public final class Cumsum<T extends TType> extends RawOp implements Operand<T> {
+public final class Cumsum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Cumsum}
@@ -100,7 +100,7 @@ private Options() {
    * @return a new instance of Cumsum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Cumsum<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Cumsum<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cumsum", scope.makeOpName("Cumsum"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(axis.asOutput());
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 82b702e4def..bb5c1ebea04 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the cumulative product of the tensor `x` along `axis`.
@@ -51,7 +51,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class CumulativeLogsumexp<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CumulativeLogsumexp<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.CumulativeLogsumexp}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of CumulativeLogsumexp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> CumulativeLogsumexp<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> CumulativeLogsumexp<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CumulativeLogsumexp", scope.makeOpName("CumulativeLogsumexp"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(axis.asOutput());
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 c217acd7f51..d16d8e203c0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes Psi, the derivative of Lgamma (the log of the absolute value of
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Digamma<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Digamma<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Digamma operation.
@@ -46,7 +46,7 @@ public final class Digamma<T extends TNumber> extends RawOp implements Operand<T
    * @return a new instance of Digamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Digamma<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Digamma<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Digamma", scope.makeOpName("Digamma"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 fb34257a1e8..c01625379d7 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x / y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Div<T extends TType> extends RawOp implements Operand<T> {
+public final class Div<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Div operation.
@@ -47,7 +47,7 @@ public final class Div<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Div
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Div<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Div<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Div", scope.makeOpName("Div"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 373dcff32cb..ed606db6286 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if the denominator is zero.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class DivNoNan<T extends TType> extends RawOp implements Operand<T> {
+public final class DivNoNan<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DivNoNan operation.
@@ -48,7 +48,7 @@ public final class DivNoNan<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of DivNoNan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DivNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> DivNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("DivNoNan", scope.makeOpName("DivNoNan"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 971a44984c6..1e94e267791 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x == y) element-wise.
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of Equal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Equal create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends Tensor> Equal create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Equal", scope.makeOpName("Equal"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 2f8e2f8c302..9fa4d11e2e0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the Gauss error function of `x` element-wise.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Erf<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Erf<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Erf operation.
@@ -44,7 +44,7 @@ public final class Erf<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Erf
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Erf<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Erf<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Erf", scope.makeOpName("Erf"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 a1494ae42a7..dcc0dd65650 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the complementary error function of `x` element-wise.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Erfc<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Erfc<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Erfc operation.
@@ -44,7 +44,7 @@ public final class Erfc<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Erfc
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Erfc<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Erfc<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Erfc", scope.makeOpName("Erfc"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 16e93c8ec2c..8542111fbff 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes exponential of x element-wise.  \\(y = e^x\\).
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Exp<T extends TType> extends RawOp implements Operand<T> {
+public final class Exp<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Exp operation.
@@ -69,7 +69,7 @@ public final class Exp<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Exp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Exp<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Exp<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Exp", scope.makeOpName("Exp"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 6998e3d3fdb..00163735d6d 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes `exp(x) - 1` element-wise.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Expm1<T extends TType> extends RawOp implements Operand<T> {
+public final class Expm1<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Expm1 operation.
@@ -58,7 +58,7 @@ public final class Expm1<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Expm1
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Expm1<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Expm1<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Expm1", scope.makeOpName("Expm1"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 fb1955c2e91..fd4573c21d7 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns element-wise largest integer not greater than x.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Floor<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Floor<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Floor operation.
@@ -44,7 +44,7 @@ public final class Floor<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Floor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Floor<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Floor<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Floor", scope.makeOpName("Floor"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 b02797cde81..eafdb394715 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x // y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class FloorDiv<T extends TType> extends RawOp implements Operand<T> {
+public final class FloorDiv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FloorDiv operation.
@@ -47,7 +47,7 @@ public final class FloorDiv<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of FloorDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> FloorDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> FloorDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("FloorDiv", scope.makeOpName("FloorDiv"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 79881c593bc..1d80323aa2a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns element-wise remainder of division. When `x < 0` xor `y < 0` is
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class FloorMod<T extends TNumber> extends RawOp implements Operand<T> {
+public final class FloorMod<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FloorMod operation.
@@ -51,7 +51,7 @@ public final class FloorMod<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of FloorMod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FloorMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> FloorMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("FloorMod", scope.makeOpName("FloorMod"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 a2aef106674..6a08ace5adf 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x > y) element-wise.
@@ -59,7 +59,7 @@ public final class Greater extends RawOp implements Operand<TBool> {
    * @return a new instance of Greater
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Greater create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> Greater create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Greater", scope.makeOpName("Greater"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 6097961d214..f1a48915994 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x >= y) element-wise.
@@ -59,7 +59,7 @@ public final class GreaterEqual extends RawOp implements Operand<TBool> {
    * @return a new instance of GreaterEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> GreaterEqual create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> GreaterEqual create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("GreaterEqual", scope.makeOpName("GreaterEqual"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 e6492c17a8e..32e3f4d33a9 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the lower regularized incomplete Gamma function `P(a, x)`.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Igamma<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Igamma<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Igamma operation.
@@ -58,7 +58,7 @@ public final class Igamma<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Igamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Igamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Igamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Igamma", scope.makeOpName("Igamma"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(x.asOutput());
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 90e5b649dc5..db91047e686 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of `igamma(a, x)` wrt `a`.
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class IgammaGradA<T extends TNumber> extends RawOp implements Operand<T> {
+public final class IgammaGradA<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new IgammaGradA operation.
@@ -44,7 +44,7 @@ public final class IgammaGradA<T extends TNumber> extends RawOp implements Opera
    * @return a new instance of IgammaGradA
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> IgammaGradA<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends Tensor & TNumber> IgammaGradA<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IgammaGradA", scope.makeOpName("IgammaGradA"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(x.asOutput());
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 03c9ab28002..4a521b87b2f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the upper regularized incomplete Gamma function `Q(a, x)`.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Igammac<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Igammac<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Igammac operation.
@@ -58,7 +58,7 @@ public final class Igammac<T extends TNumber> extends RawOp implements Operand<T
    * @return a new instance of Igammac
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Igammac<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Igammac<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Igammac", scope.makeOpName("Igammac"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(x.asOutput());
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 dbd5b5b8406..eb3b746cbb7 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the imaginary part of a complex number.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Imag<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Imag<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Imag operation.
@@ -59,7 +59,7 @@ public final class Imag<U extends TNumber> extends RawOp implements Operand<U> {
    * @return a new instance of Imag
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Imag<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Imag<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Imag", scope.makeOpName("Imag"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -75,7 +75,7 @@ public static <U extends TNumber, T extends TType> Imag<U> create(Scope scope, O
    * @return a new instance of Imag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Imag<TFloat32> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Imag<TFloat32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TFloat32.DTYPE);
   }
   
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 28d0a80d4ad..4befe1f36d6 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the inverse permutation of a tensor.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class InvertPermutation<T extends TNumber> extends RawOp implements Operand<T> {
+public final class InvertPermutation<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InvertPermutation operation.
@@ -60,7 +60,7 @@ public final class InvertPermutation<T extends TNumber> extends RawOp implements
    * @return a new instance of InvertPermutation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> InvertPermutation<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> InvertPermutation<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("InvertPermutation", scope.makeOpName("InvertPermutation"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 b8136095909..abd8d0af84c 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns which elements of x are finite.
@@ -54,7 +54,7 @@ public final class IsFinite extends RawOp implements Operand<TBool> {
    * @return a new instance of IsFinite
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> IsFinite create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> IsFinite create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsFinite", scope.makeOpName("IsFinite"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 429e8aee411..3e442b86e84 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns which elements of x are Inf.
@@ -54,7 +54,7 @@ public final class IsInf extends RawOp implements Operand<TBool> {
    * @return a new instance of IsInf
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> IsInf create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> IsInf create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsInf", scope.makeOpName("IsInf"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1c480c08336..17e27eef753 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns which elements of x are NaN.
@@ -54,7 +54,7 @@ public final class IsNan extends RawOp implements Operand<TBool> {
    * @return a new instance of IsNan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> IsNan create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> IsNan create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsNan", scope.makeOpName("IsNan"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 106040ab8b1..9e9f470f7a1 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x < y) element-wise.
@@ -59,7 +59,7 @@ public final class Less extends RawOp implements Operand<TBool> {
    * @return a new instance of Less
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Less create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> Less create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Less", scope.makeOpName("Less"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 094bd19e36c..29e94952061 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x <= y) element-wise.
@@ -59,7 +59,7 @@ public final class LessEqual extends RawOp implements Operand<TBool> {
    * @return a new instance of LessEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LessEqual create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> LessEqual create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("LessEqual", scope.makeOpName("LessEqual"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 42a5baad397..a2fbbcbea08 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the log of the absolute value of `Gamma(x)` element-wise.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Lgamma<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Lgamma<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Lgamma operation.
@@ -54,7 +54,7 @@ public final class Lgamma<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Lgamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Lgamma<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Lgamma<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Lgamma", scope.makeOpName("Lgamma"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1ee4bc3c6e2..97206730d28 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes natural logarithm of x element-wise.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Log<T extends TType> extends RawOp implements Operand<T> {
+public final class Log<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Log operation.
@@ -52,7 +52,7 @@ public final class Log<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Log
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Log<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Log<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Log", scope.makeOpName("Log"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 407cfa649ad..8b53d6f7121 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes natural logarithm of (1 + x) element-wise.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Log1p<T extends TType> extends RawOp implements Operand<T> {
+public final class Log1p<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Log1p operation.
@@ -52,7 +52,7 @@ public final class Log1p<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Log1p
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Log1p<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Log1p<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Log1p", scope.makeOpName("Log1p"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 998e5fbc3bf..eec3edcc74f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the max of x and y (i.e. x > y ? x : y) element-wise.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Maximum<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Maximum<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Maximum operation.
@@ -48,7 +48,7 @@ public final class Maximum<T extends TNumber> extends RawOp implements Operand<T
    * @return a new instance of Maximum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Maximum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> Maximum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Maximum", scope.makeOpName("Maximum"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 301ff6b1c31..21d824df360 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the mean of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Mean<T extends TType> extends RawOp implements Operand<T> {
+public final class Mean<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Mean}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of Mean
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Mean<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Mean<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Mean", scope.makeOpName("Mean"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(axis.asOutput());
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 33f6fe5d7af..0f07335a85c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the min of x and y (i.e. x < y ? x : y) element-wise.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Minimum<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Minimum<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Minimum operation.
@@ -48,7 +48,7 @@ public final class Minimum<T extends TNumber> extends RawOp implements Operand<T
    * @return a new instance of Minimum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Minimum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> Minimum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Minimum", scope.makeOpName("Minimum"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 8cd9b2cd30d..f6df61b1346 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns element-wise remainder of division. This emulates C semantics in that
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Mod<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Mod<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Mod operation.
@@ -51,7 +51,7 @@ public final class Mod<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Mod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Mod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> Mod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Mod", scope.makeOpName("Mod"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 d4cf53f8540..8b35d5fe0c8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x * y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Mul<T extends TType> extends RawOp implements Operand<T> {
+public final class Mul<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Mul operation.
@@ -47,7 +47,7 @@ public final class Mul<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Mul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Mul<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Mul<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Mul", scope.makeOpName("Mul"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 157b5d1ead0..2178e0c6b3f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x * y element-wise. Returns zero if y is zero, even if x if infinite or NaN.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class MulNoNan<T extends TType> extends RawOp implements Operand<T> {
+public final class MulNoNan<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new MulNoNan operation.
@@ -47,7 +47,7 @@ public final class MulNoNan<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of MulNoNan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MulNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> MulNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("MulNoNan", scope.makeOpName("MulNoNan"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 0330942d8b3..39dec8488c0 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Ndtri<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Ndtri<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ndtri operation.
@@ -42,7 +42,7 @@ public final class Ndtri<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Ndtri
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Ndtri<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Ndtri<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Ndtri", scope.makeOpName("Ndtri"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 14a1544cb82..5bfb96281c1 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes numerical negative value element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Neg<T extends TType> extends RawOp implements Operand<T> {
+public final class Neg<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Neg operation.
@@ -45,7 +45,7 @@ public final class Neg<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Neg
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Neg<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Neg<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Neg", scope.makeOpName("Neg"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 4ac1cde3380..fa30f0a5692 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the next representable value of `x1` in the direction of `x2`, element-wise.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class NextAfter<T extends TNumber> extends RawOp implements Operand<T> {
+public final class NextAfter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new NextAfter operation.
@@ -53,7 +53,7 @@ public final class NextAfter<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of NextAfter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> NextAfter<T> create(Scope scope, Operand<T> x1, Operand<T> x2) {
+  public static <T extends Tensor & TNumber> NextAfter<T> create(Scope scope, Operand<T> x1, Operand<T> x2) {
     OperationBuilder opBuilder = scope.env().opBuilder("NextAfter", scope.makeOpName("NextAfter"));
     opBuilder.addInput(x1.asOutput());
     opBuilder.addInput(x2.asOutput());
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 647b596f6be..5592d5ba668 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x != y) element-wise.
@@ -66,7 +66,7 @@ private Options() {
    * @return a new instance of NotEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> NotEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends Tensor> NotEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("NotEqual", scope.makeOpName("NotEqual"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 415b5b51837..0133142551c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the polygamma function \\(\psi^{(n)}(x)\\).
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Polygamma<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Polygamma<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Polygamma operation.
@@ -52,7 +52,7 @@ public final class Polygamma<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of Polygamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Polygamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Polygamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Polygamma", scope.makeOpName("Polygamma"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(x.asOutput());
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 21b22d86fa5..f1c9fc1811e 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TUint8;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes element-wise population count (a.k.a. popcount, bitsum, bitcount).
@@ -50,7 +50,7 @@ public final class PopulationCount extends RawOp implements Operand<TUint8> {
    * @return a new instance of PopulationCount
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> PopulationCount create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> PopulationCount create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("PopulationCount", scope.makeOpName("PopulationCount"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 cd22d351e6e..1b10d6d3c15 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the power of one value to another.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Pow<T extends TType> extends RawOp implements Operand<T> {
+public final class Pow<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Pow operation.
@@ -53,7 +53,7 @@ public final class Pow<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Pow
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Pow<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Pow<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Pow", scope.makeOpName("Pow"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 fd2f5890d47..c19f5e28dd8 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x + y element-wise, working on quantized buffers.
@@ -35,7 +35,7 @@
  * @param <V> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class QuantizedAdd<V extends TType> extends RawOp {
+public final class QuantizedAdd<V extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedAdd operation.
@@ -51,7 +51,7 @@ public final class QuantizedAdd<V extends TType> extends RawOp {
    * @return a new instance of QuantizedAdd
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedAdd<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedAdd<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedAdd", scope.makeOpName("QuantizedAdd"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 a629145fa62..773336d3966 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x * y element-wise, working on quantized buffers.
@@ -35,7 +35,7 @@
  * @param <V> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class QuantizedMul<V extends TType> extends RawOp {
+public final class QuantizedMul<V extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedMul operation.
@@ -51,7 +51,7 @@ public final class QuantizedMul<V extends TType> extends RawOp {
    * @return a new instance of QuantizedMul
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedMul<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedMul<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMul", scope.makeOpName("QuantizedMul"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 0b619946e0b..3d8e66416a1 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the real part of a complex number.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Real<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Real<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Real operation.
@@ -59,7 +59,7 @@ public final class Real<U extends TNumber> extends RawOp implements Operand<U> {
    * @return a new instance of Real
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Real<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Real<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Real", scope.makeOpName("Real"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -75,7 +75,7 @@ public static <U extends TNumber, T extends TType> Real<U> create(Scope scope, O
    * @return a new instance of Real
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Real<TFloat32> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Real<TFloat32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TFloat32.DTYPE);
   }
   
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 32dcc8988fc..9ef6de048b6 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x / y element-wise for real types.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class RealDiv<T extends TType> extends RawOp implements Operand<T> {
+public final class RealDiv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RealDiv operation.
@@ -49,7 +49,7 @@ public final class RealDiv<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of RealDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RealDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> RealDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("RealDiv", scope.makeOpName("RealDiv"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 b39118351c5..60ba376974e 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the reciprocal of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Reciprocal<T extends TType> extends RawOp implements Operand<T> {
+public final class Reciprocal<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Reciprocal operation.
@@ -45,7 +45,7 @@ public final class Reciprocal<T extends TType> extends RawOp implements Operand<
    * @return a new instance of Reciprocal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Reciprocal<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Reciprocal<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Reciprocal", scope.makeOpName("Reciprocal"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 9d9a1f03723..9fdf8dba280 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the inverse of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class ReciprocalGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class ReciprocalGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ReciprocalGrad operation.
@@ -46,7 +46,7 @@ public final class ReciprocalGrad<T extends TType> extends RawOp implements Oper
    * @return a new instance of ReciprocalGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ReciprocalGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends Tensor> ReciprocalGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReciprocalGrad", scope.makeOpName("ReciprocalGrad"));
     opBuilder.addInput(y.asOutput());
     opBuilder.addInput(dy.asOutput());
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 659dae182cf..ff393a3fc3b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes requantization range per channel.
@@ -45,7 +45,7 @@ public final class RequantizationRangePerChannel extends RawOp {
    * @return a new instance of RequantizationRangePerChannel
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RequantizationRangePerChannel create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Float clipValueMax) {
+  public static <T extends Tensor> RequantizationRangePerChannel create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Float clipValueMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("RequantizationRangePerChannel", scope.makeOpName("RequantizationRangePerChannel"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputMin.asOutput());
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 793429b9779..430229fde64 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Requantizes input with min and max values known per channel.
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class RequantizePerChannel<U extends TType> extends RawOp {
+public final class RequantizePerChannel<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RequantizePerChannel operation.
@@ -49,7 +49,7 @@ public final class RequantizePerChannel<U extends TType> extends RawOp {
    * @return a new instance of RequantizePerChannel
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> RequantizePerChannel<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> RequantizePerChannel<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("RequantizePerChannel", scope.makeOpName("RequantizePerChannel"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputMin.asOutput());
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 576508d7d30..2b8b4edbf21 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns element-wise integer closest to x.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Rint<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Rint<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Rint operation.
@@ -54,7 +54,7 @@ public final class Rint<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Rint
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Rint<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Rint<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Rint", scope.makeOpName("Rint"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 dbd546baf23..ecc60b82461 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Rounds the values of a tensor to the nearest integer, element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Round<T extends TType> extends RawOp implements Operand<T> {
+public final class Round<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Round operation.
@@ -46,7 +46,7 @@ public final class Round<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Round
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Round<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Round<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Round", scope.makeOpName("Round"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 43a6886684d..2d91d211f82 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes reciprocal of square root of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Rsqrt<T extends TType> extends RawOp implements Operand<T> {
+public final class Rsqrt<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Rsqrt operation.
@@ -45,7 +45,7 @@ public final class Rsqrt<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Rsqrt
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Rsqrt<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Rsqrt<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Rsqrt", scope.makeOpName("Rsqrt"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 df8cdcfb392..b3ced8e9431 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the rsqrt of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class RsqrtGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class RsqrtGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RsqrtGrad operation.
@@ -46,7 +46,7 @@ public final class RsqrtGrad<T extends TType> extends RawOp implements Operand<T
    * @return a new instance of RsqrtGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RsqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends Tensor> RsqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("RsqrtGrad", scope.makeOpName("RsqrtGrad"));
     opBuilder.addInput(y.asOutput());
     opBuilder.addInput(dy.asOutput());
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 99c1bda676b..4ca3e332b7f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the maximum along segments of a tensor.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SegmentMax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentMax operation.
@@ -69,7 +69,7 @@ public final class SegmentMax<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of SegmentMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentMax", scope.makeOpName("SegmentMax"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 263a550e74c..f46867f05f8 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the mean along segments of a tensor.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMean<T extends TType> extends RawOp implements Operand<T> {
+public final class SegmentMean<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentMean operation.
@@ -70,7 +70,7 @@ public final class SegmentMean<T extends TType> extends RawOp implements Operand
    * @return a new instance of SegmentMean
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentMean", scope.makeOpName("SegmentMean"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 38a0e75784c..eb2470fc01c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the minimum along segments of a tensor.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMin<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SegmentMin<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentMin operation.
@@ -69,7 +69,7 @@ public final class SegmentMin<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of SegmentMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentMin", scope.makeOpName("SegmentMin"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 36592e64f85..44d2d9abd51 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product along segments of a tensor.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentProd<T extends TType> extends RawOp implements Operand<T> {
+public final class SegmentProd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentProd operation.
@@ -69,7 +69,7 @@ public final class SegmentProd<T extends TType> extends RawOp implements Operand
    * @return a new instance of SegmentProd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentProd", scope.makeOpName("SegmentProd"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 54287c045b2..39bb1760032 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along segments of a tensor.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentSum<T extends TType> extends RawOp implements Operand<T> {
+public final class SegmentSum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SegmentSum operation.
@@ -69,7 +69,7 @@ public final class SegmentSum<T extends TType> extends RawOp implements Operand<
    * @return a new instance of SegmentSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentSum", scope.makeOpName("SegmentSum"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 a12d7061324..37494783825 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes sigmoid of `x` element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sigmoid<T extends TType> extends RawOp implements Operand<T> {
+public final class Sigmoid<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sigmoid operation.
@@ -45,7 +45,7 @@ public final class Sigmoid<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Sigmoid
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sigmoid<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Sigmoid<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sigmoid", scope.makeOpName("Sigmoid"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c53a0ae603f..bd84abe5a06 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of the sigmoid of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class SigmoidGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class SigmoidGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SigmoidGrad operation.
@@ -46,7 +46,7 @@ public final class SigmoidGrad<T extends TType> extends RawOp implements Operand
    * @return a new instance of SigmoidGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SigmoidGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends Tensor> SigmoidGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("SigmoidGrad", scope.makeOpName("SigmoidGrad"));
     opBuilder.addInput(y.asOutput());
     opBuilder.addInput(dy.asOutput());
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 6591ed77c71..153ce0c1e35 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns an element-wise indication of the sign of a number.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sign<T extends TType> extends RawOp implements Operand<T> {
+public final class Sign<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sign operation.
@@ -51,7 +51,7 @@ public final class Sign<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Sign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sign<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Sign<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sign", scope.makeOpName("Sign"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 15ef4b31dd2..f76834c0ab9 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes sine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sin<T extends TType> extends RawOp implements Operand<T> {
+public final class Sin<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sin operation.
@@ -53,7 +53,7 @@ public final class Sin<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Sin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sin<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Sin<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sin", scope.makeOpName("Sin"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 8785916850b..e83292babad 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes hyperbolic sine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sinh<T extends TType> extends RawOp implements Operand<T> {
+public final class Sinh<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sinh operation.
@@ -53,7 +53,7 @@ public final class Sinh<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Sinh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sinh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Sinh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sinh", scope.makeOpName("Sinh"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java
index d66475e2071..7b1b28e8ad6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java
@@ -22,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Generates points from the Sobol sequence.
@@ -39,7 +39,7 @@
  * 
  * @param <T> data type for {@code samples()} output
  */
-public final class SobolSample<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SobolSample<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SobolSample operation.
@@ -54,7 +54,7 @@ public final class SobolSample<T extends TNumber> extends RawOp implements Opera
    * @return a new instance of SobolSample
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SobolSample<T> create(Scope scope, Operand<TInt32> dim, Operand<TInt32> numResults, Operand<TInt32> skip, DataType<T> dtype) {
+  public static <T extends Tensor & TNumber> SobolSample<T> create(Scope scope, Operand<TInt32> dim, Operand<TInt32> numResults, Operand<TInt32> skip, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("SobolSample", scope.makeOpName("SobolSample"));
     opBuilder.addInput(dim.asOutput());
     opBuilder.addInput(numResults.asOutput());
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 a4f3a22ebcd..4e41165d496 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes softplus: `log(exp(features) + 1)`.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "math")
-public final class Softplus<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Softplus<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Softplus operation.
@@ -44,7 +44,7 @@ public final class Softplus<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of Softplus
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Softplus<T> create(Scope scope, Operand<T> features) {
+  public static <T extends Tensor & TNumber> Softplus<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Softplus", scope.makeOpName("Softplus"));
     opBuilder.addInput(features.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 f885abcbdeb..06be5e484aa 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes softplus gradients for a softplus operation.
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SoftplusGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SoftplusGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SoftplusGrad operation.
@@ -44,7 +44,7 @@ public final class SoftplusGrad<T extends TNumber> extends RawOp implements Oper
    * @return a new instance of SoftplusGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SoftplusGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends Tensor & TNumber> SoftplusGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("SoftplusGrad", scope.makeOpName("SoftplusGrad"));
     opBuilder.addInput(gradients.asOutput());
     opBuilder.addInput(features.asOutput());
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 315173746b2..aaf89d7e457 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes square root of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sqrt<T extends TType> extends RawOp implements Operand<T> {
+public final class Sqrt<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sqrt operation.
@@ -45,7 +45,7 @@ public final class Sqrt<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Sqrt
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sqrt<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Sqrt<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sqrt", scope.makeOpName("Sqrt"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 5ba9497bbdd..eb5bd051a28 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the sqrt of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class SqrtGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class SqrtGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SqrtGrad operation.
@@ -46,7 +46,7 @@ public final class SqrtGrad<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of SqrtGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends Tensor> SqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("SqrtGrad", scope.makeOpName("SqrtGrad"));
     opBuilder.addInput(y.asOutput());
     opBuilder.addInput(dy.asOutput());
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 36fdb6bda9c..a8c3ed5312f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes square of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Square<T extends TType> extends RawOp implements Operand<T> {
+public final class Square<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Square operation.
@@ -45,7 +45,7 @@ public final class Square<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Square
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Square<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Square<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Square", scope.makeOpName("Square"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c860747add8..7c9bc1ff285 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns (x - y)(x - y) element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class SquaredDifference<T extends TType> extends RawOp implements Operand<T> {
+public final class SquaredDifference<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SquaredDifference operation.
@@ -47,7 +47,7 @@ public final class SquaredDifference<T extends TType> extends RawOp implements O
    * @return a new instance of SquaredDifference
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SquaredDifference<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> SquaredDifference<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("SquaredDifference", scope.makeOpName("SquaredDifference"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 1489a80202d..54cc73e80c3 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x - y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Sub<T extends TType> extends RawOp implements Operand<T> {
+public final class Sub<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sub operation.
@@ -47,7 +47,7 @@ public final class Sub<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Sub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sub<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Sub<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sub", scope.makeOpName("Sub"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 1b1ddd50ba5..168c294dfb4 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes tan of x element-wise.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Tan<T extends TType> extends RawOp implements Operand<T> {
+public final class Tan<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Tan operation.
@@ -54,7 +54,7 @@ public final class Tan<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Tan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Tan<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Tan<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Tan", scope.makeOpName("Tan"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 f2611083984..d9005cbb7dd 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes hyperbolic tangent of `x` element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Tanh<T extends TType> extends RawOp implements Operand<T> {
+public final class Tanh<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Tanh operation.
@@ -53,7 +53,7 @@ public final class Tanh<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Tanh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Tanh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor> Tanh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Tanh", scope.makeOpName("Tanh"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 3ebc6ab598d..4f7ab7a3cbb 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the tanh of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class TanhGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class TanhGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TanhGrad operation.
@@ -46,7 +46,7 @@ public final class TanhGrad<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of TanhGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TanhGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends Tensor> TanhGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("TanhGrad", scope.makeOpName("TanhGrad"));
     opBuilder.addInput(y.asOutput());
     opBuilder.addInput(dy.asOutput());
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 a0a1f6697d1..15e6ce321b7 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns x / y element-wise for integer types.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class TruncateDiv<T extends TType> extends RawOp implements Operand<T> {
+public final class TruncateDiv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TruncateDiv operation.
@@ -52,7 +52,7 @@ public final class TruncateDiv<T extends TType> extends RawOp implements Operand
    * @return a new instance of TruncateDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TruncateDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> TruncateDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("TruncateDiv", scope.makeOpName("TruncateDiv"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 cfa0461f460..60cc6819a6b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns element-wise remainder of division. This emulates C semantics in that
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class TruncateMod<T extends TNumber> extends RawOp implements Operand<T> {
+public final class TruncateMod<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TruncateMod operation.
@@ -51,7 +51,7 @@ public final class TruncateMod<T extends TNumber> extends RawOp implements Opera
    * @return a new instance of TruncateMod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> TruncateMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor & TNumber> TruncateMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("TruncateMod", scope.makeOpName("TruncateMod"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 4c509457c3e..96bb629837b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the maximum along segments of a tensor.
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentMax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class UnsortedSegmentMax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentMax operation.
@@ -77,7 +77,7 @@ public final class UnsortedSegmentMax<T extends TNumber> extends RawOp implement
    * @return a new instance of UnsortedSegmentMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentMax", scope.makeOpName("UnsortedSegmentMax"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 bd12cae09b9..a866fff93ed 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the minimum along segments of a tensor.
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentMin<T extends TNumber> extends RawOp implements Operand<T> {
+public final class UnsortedSegmentMin<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentMin operation.
@@ -71,7 +71,7 @@ public final class UnsortedSegmentMin<T extends TNumber> extends RawOp implement
    * @return a new instance of UnsortedSegmentMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentMin", scope.makeOpName("UnsortedSegmentMin"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 86f2b588cc0..030d3083fef 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product along segments of a tensor.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentProd<T extends TType> extends RawOp implements Operand<T> {
+public final class UnsortedSegmentProd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentProd operation.
@@ -70,7 +70,7 @@ public final class UnsortedSegmentProd<T extends TType> extends RawOp implements
    * @return a new instance of UnsortedSegmentProd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentProd", scope.makeOpName("UnsortedSegmentProd"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 95868ce64d0..15880b264b7 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along segments of a tensor.
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentSum<T extends TType> extends RawOp implements Operand<T> {
+public final class UnsortedSegmentSum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new UnsortedSegmentSum operation.
@@ -73,7 +73,7 @@ public final class UnsortedSegmentSum<T extends TType> extends RawOp implements
    * @return a new instance of UnsortedSegmentSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentSum", scope.makeOpName("UnsortedSegmentSum"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 5372f4b5c11..364ecb2931b 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if x == 0, and x / y otherwise, elementwise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xdivy<T extends TType> extends RawOp implements Operand<T> {
+public final class Xdivy<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Xdivy operation.
@@ -44,7 +44,7 @@ public final class Xdivy<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Xdivy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Xdivy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Xdivy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Xdivy", scope.makeOpName("Xdivy"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java
index f0586582e8c..180d995ecc4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if x == 0, and x * log1p(y) otherwise, elementwise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xlog1py<T extends TType> extends RawOp implements Operand<T> {
+public final class Xlog1py<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Xlog1py operation.
@@ -44,7 +44,7 @@ public final class Xlog1py<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Xlog1py
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Xlog1py<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Xlog1py<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Xlog1py", scope.makeOpName("Xlog1py"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 6b303403408..8aa86bbecd2 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if x == 0, and x * log(y) otherwise, elementwise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xlogy<T extends TType> extends RawOp implements Operand<T> {
+public final class Xlogy<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Xlogy operation.
@@ -44,7 +44,7 @@ public final class Xlogy<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Xlogy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Xlogy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends Tensor> Xlogy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Xlogy", scope.makeOpName("Xlogy"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 431921f8e2b..3e6998f3594 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Compute the Hurwitz zeta function \\(\zeta(x, q)\\).
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Zeta<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Zeta<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Zeta operation.
@@ -49,7 +49,7 @@ public final class Zeta<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Zeta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Zeta<T> create(Scope scope, Operand<T> x, Operand<T> q) {
+  public static <T extends Tensor & TNumber> Zeta<T> create(Scope scope, Operand<T> x, Operand<T> q) {
     OperationBuilder opBuilder = scope.env().opBuilder("Zeta", scope.makeOpName("Zeta"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(q.asOutput());
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 385bd855018..64b1b796213 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class erfinv<T extends TNumber> extends RawOp implements Operand<T> {
+public final class erfinv<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new erfinv operation.
@@ -42,7 +42,7 @@ public final class erfinv<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of erfinv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> erfinv<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> erfinv<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Erfinv", scope.makeOpName("erfinv"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java
index 0855403368a..de63db71cfa 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java
@@ -21,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class Dawsn<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Dawsn<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dawsn operation.
@@ -41,7 +41,7 @@ public final class Dawsn<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Dawsn
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Dawsn<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Dawsn<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dawsn", scope.makeOpName("Dawsn"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java
index 1d2aa725fce..1a66105c075 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java
@@ -21,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class Expint<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Expint<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Expint operation.
@@ -41,7 +41,7 @@ public final class Expint<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Expint
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Expint<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Expint<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Expint", scope.makeOpName("Expint"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java
index 732cfb1ac20..22e89de3647 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java
@@ -21,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class FresnelCos<T extends TNumber> extends RawOp implements Operand<T> {
+public final class FresnelCos<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FresnelCos operation.
@@ -41,7 +41,7 @@ public final class FresnelCos<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of FresnelCos
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FresnelCos<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> FresnelCos<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("FresnelCos", scope.makeOpName("FresnelCos"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java
index cab6e46cba8..6197798a236 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java
@@ -21,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class FresnelSin<T extends TNumber> extends RawOp implements Operand<T> {
+public final class FresnelSin<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FresnelSin operation.
@@ -41,7 +41,7 @@ public final class FresnelSin<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of FresnelSin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FresnelSin<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> FresnelSin<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("FresnelSin", scope.makeOpName("FresnelSin"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java
index c313fb84aee..f9b1827496f 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java
@@ -21,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class Spence<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Spence<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Spence operation.
@@ -41,7 +41,7 @@ public final class Spence<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Spence
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Spence<T> create(Scope scope, Operand<T> x) {
+  public static <T extends Tensor & TNumber> Spence<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Spence", scope.makeOpName("Spence"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 de1a858b738..34609fc7dd2 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs average pooling on the input.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AvgPool<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of AvgPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AvgPool<T> create(Scope scope, Operand<T> value, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> AvgPool<T> create(Scope scope, Operand<T> value, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPool", scope.makeOpName("AvgPool"));
     opBuilder.addInput(value.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1700745d1ba..56137eae22f 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs 3D average pooling on the input.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool3d<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AvgPool3d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool3d}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of AvgPool3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AvgPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> AvgPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPool3D", scope.makeOpName("AvgPool3d"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 9426ff8f682..a6c279225d4 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients of average pooling function.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool3dGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AvgPool3dGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool3dGrad}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of AvgPool3dGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AvgPool3dGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> AvgPool3dGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPool3DGrad", scope.makeOpName("AvgPool3dGrad"));
     opBuilder.addInput(origInputShape.asOutput());
     opBuilder.addInput(grad.asOutput());
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 9389f98ad3b..c893b817da2 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,20 +22,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients of the average pooling function.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AvgPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class AvgPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPoolGrad}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of AvgPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> AvgPoolGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> AvgPoolGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPoolGrad", scope.makeOpName("AvgPoolGrad"));
     opBuilder.addInput(origInputShape.asOutput());
     opBuilder.addInput(grad.asOutput());
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 23cc0b463ba..6ecc5a694a6 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Batch normalization.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code result()} output
  */
 @Operator(group = "nn")
-public final class BatchNormWithGlobalNormalization<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchNormWithGlobalNormalization<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new BatchNormWithGlobalNormalization operation.
@@ -59,7 +59,7 @@ public final class BatchNormWithGlobalNormalization<T extends TType> extends Raw
    * @return a new instance of BatchNormWithGlobalNormalization
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchNormWithGlobalNormalization<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> beta, Operand<T> gamma, Float varianceEpsilon, Boolean scaleAfterNormalization) {
+  public static <T extends Tensor> BatchNormWithGlobalNormalization<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> beta, Operand<T> gamma, Float varianceEpsilon, Boolean scaleAfterNormalization) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchNormWithGlobalNormalization", scope.makeOpName("BatchNormWithGlobalNormalization"));
     opBuilder.addInput(t.asOutput());
     opBuilder.addInput(m.asOutput());
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 fe2813b3342..211c4d8c7a4 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gradients for batch normalization.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code dx()} output
  */
 @Operator(group = "nn")
-public final class BatchNormWithGlobalNormalizationGrad<T extends TType> extends RawOp {
+public final class BatchNormWithGlobalNormalizationGrad<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BatchNormWithGlobalNormalizationGrad operation.
@@ -58,7 +58,7 @@ public final class BatchNormWithGlobalNormalizationGrad<T extends TType> extends
    * @return a new instance of BatchNormWithGlobalNormalizationGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchNormWithGlobalNormalizationGrad<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> gamma, Operand<T> backprop, Float varianceEpsilon, Boolean scaleAfterNormalization) {
+  public static <T extends Tensor> BatchNormWithGlobalNormalizationGrad<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> gamma, Operand<T> backprop, Float varianceEpsilon, Boolean scaleAfterNormalization) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchNormWithGlobalNormalizationGrad", scope.makeOpName("BatchNormWithGlobalNormalizationGrad"));
     opBuilder.addInput(t.asOutput());
     opBuilder.addInput(m.asOutput());
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 6296f75db61..9a4fa545bd4 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds `bias` to `value`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class BiasAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class BiasAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BiasAdd}
@@ -73,7 +73,7 @@ private Options() {
    * @return a new instance of BiasAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BiasAdd<T> create(Scope scope, Operand<T> value, Operand<T> bias, Options... options) {
+  public static <T extends Tensor> BiasAdd<T> create(Scope scope, Operand<T> value, Operand<T> bias, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BiasAdd", scope.makeOpName("BiasAdd"));
     opBuilder.addInput(value.asOutput());
     opBuilder.addInput(bias.asOutput());
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 dcc2b537f65..ed6890c3649 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * The backward operation for "BiasAdd" on the "bias" tensor.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class BiasAddGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class BiasAddGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BiasAddGrad}
@@ -73,7 +73,7 @@ private Options() {
    * @return a new instance of BiasAddGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BiasAddGrad<T> create(Scope scope, Operand<T> outBackprop, Options... options) {
+  public static <T extends Tensor> BiasAddGrad<T> create(Scope scope, Operand<T> outBackprop, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BiasAddGrad", scope.makeOpName("BiasAddGrad"));
     opBuilder.addInput(outBackprop.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 22f0d16f540..ca1106a6c87 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the LSTM cell forward propagation for all the time steps.
@@ -56,7 +56,7 @@
  * 
  * @param <T> data type for {@code i()} output
  */
-public final class BlockLSTM<T extends TNumber> extends RawOp {
+public final class BlockLSTM<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BlockLSTM}
@@ -104,7 +104,7 @@ private Options() {
    * @return a new instance of BlockLSTM
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BlockLSTM<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
+  public static <T extends Tensor & TNumber> BlockLSTM<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BlockLSTMV2", scope.makeOpName("BlockLSTM"));
     opBuilder.addInput(seqLenMax.asOutput());
     opBuilder.addInput(x.asOutput());
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 e80bea4006d..6ec2880abc3 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the LSTM cell backward propagation for the entire time sequence.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code xGrad()} output
  */
-public final class BlockLSTMGrad<T extends TNumber> extends RawOp {
+public final class BlockLSTMGrad<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BlockLSTMGrad operation.
@@ -65,7 +65,7 @@ public final class BlockLSTMGrad<T extends TNumber> extends RawOp {
    * @return a new instance of BlockLSTMGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> BlockLSTMGrad<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> h, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
+  public static <T extends Tensor & TNumber> BlockLSTMGrad<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> h, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
     OperationBuilder opBuilder = scope.env().opBuilder("BlockLSTMGradV2", scope.makeOpName("BlockLSTMGrad"));
     opBuilder.addInput(seqLenMax.asOutput());
     opBuilder.addInput(x.asOutput());
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 632d54c3890..5a713b3cf1f 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes a 2-D convolution given 4-D `input` and `filter` tensors.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2d<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Conv2d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2d}
@@ -132,7 +132,7 @@ private Options() {
    * @return a new instance of Conv2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Conv2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> Conv2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv2D", scope.makeOpName("Conv2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 91e147def81..6adfcf516cf 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradients of convolution with respect to the filter.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Conv2dBackpropFilter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2dBackpropFilter}
@@ -113,7 +113,7 @@ private Options() {
    * @return a new instance of Conv2dBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Conv2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> Conv2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv2DBackpropFilter", scope.makeOpName("Conv2dBackpropFilter"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filterSizes.asOutput());
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 389ddb0be4e..73abfb16055 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradients of convolution with respect to the input.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2dBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Conv2dBackpropInput<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2dBackpropInput}
@@ -113,7 +113,7 @@ private Options() {
    * @return a new instance of Conv2dBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Conv2dBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> Conv2dBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv2DBackpropInput", scope.makeOpName("Conv2dBackpropInput"));
     opBuilder.addInput(inputSizes.asOutput());
     opBuilder.addInput(filter.asOutput());
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 1e80fdb7f80..d73496a5402 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes a 3-D convolution given 5-D `input` and `filter` tensors.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3d<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Conv3d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3d}
@@ -93,7 +93,7 @@ private Options() {
    * @return a new instance of Conv3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Conv3d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> Conv3d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv3D", scope.makeOpName("Conv3d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 d6d85797b3f..45a628f4475 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradients of 3-D convolution with respect to the filter.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Conv3dBackpropFilter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3dBackpropFilter}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of Conv3dBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Conv3dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> Conv3dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv3DBackpropFilterV2", scope.makeOpName("Conv3dBackpropFilter"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filterSizes.asOutput());
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 08e163494bf..92fe9088aa8 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradients of 3-D convolution with respect to the input.
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3dBackpropInput<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Conv3dBackpropInput<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3dBackpropInput}
@@ -91,7 +91,7 @@ private Options() {
    * @return a new instance of Conv3dBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> Conv3dBackpropInput<U> create(Scope scope, Operand<T> inputSizes, Operand<U> filter, Operand<U> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> Conv3dBackpropInput<U> create(Scope scope, Operand<T> inputSizes, Operand<U> filter, Operand<U> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv3DBackpropInputV2", scope.makeOpName("Conv3dBackpropInput"));
     opBuilder.addInput(inputSizes.asOutput());
     opBuilder.addInput(filter.asOutput());
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 8d212909901..055c8cc9e4c 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,6 +23,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -30,7 +31,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs beam search decoding on the logits given in input.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code logProbability()} output
  */
 @Operator(group = "nn")
-public final class CtcBeamSearchDecoder<T extends TNumber> extends RawOp {
+public final class CtcBeamSearchDecoder<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcBeamSearchDecoder}
@@ -77,7 +77,7 @@ private Options() {
    * @return a new instance of CtcBeamSearchDecoder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CtcBeamSearchDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths, Options... options) {
+  public static <T extends Tensor & TNumber> CtcBeamSearchDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CTCBeamSearchDecoder", scope.makeOpName("CtcBeamSearchDecoder"));
     opBuilder.addInput(inputs.asOutput());
     opBuilder.addInput(sequenceLength.asOutput());
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 eecea029a34..c32fd0b9bd6 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs greedy decoding on the logits given in inputs.
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code logProbability()} output
  */
 @Operator(group = "nn")
-public final class CtcGreedyDecoder<T extends TNumber> extends RawOp {
+public final class CtcGreedyDecoder<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcGreedyDecoder}
@@ -77,7 +77,7 @@ private Options() {
    * @return a new instance of CtcGreedyDecoder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CtcGreedyDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Options... options) {
+  public static <T extends Tensor & TNumber> CtcGreedyDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CTCGreedyDecoder", scope.makeOpName("CtcGreedyDecoder"));
     opBuilder.addInput(inputs.asOutput());
     opBuilder.addInput(sequenceLength.asOutput());
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 b39f344373e..ab5bff6dc1d 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Calculates the CTC Loss (log probability) for each batch entry.  Also calculates
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class CtcLoss<T extends TNumber> extends RawOp {
+public final class CtcLoss<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcLoss}
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of CtcLoss
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CtcLoss<T> create(Scope scope, Operand<T> inputs, Operand<TInt64> labelsIndices, Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength, Options... options) {
+  public static <T extends Tensor & TNumber> CtcLoss<T> create(Scope scope, Operand<T> inputs, Operand<TInt64> labelsIndices, Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CTCLoss", scope.makeOpName("CtcLoss"));
     opBuilder.addInput(inputs.asOutput());
     opBuilder.addInput(labelsIndices.asOutput());
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 9159d1c69c3..c083d7618be 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * A RNN backed by cuDNN.
@@ -72,7 +72,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CudnnRNN<T extends TNumber> extends RawOp {
+public final class CudnnRNN<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNN}
@@ -178,7 +178,7 @@ private Options() {
    * @return a new instance of CudnnRNN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CudnnRNN<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Options... options) {
+  public static <T extends Tensor & TNumber> CudnnRNN<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNV3", scope.makeOpName("CudnnRNN"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputH.asOutput());
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 adeadb27292..d16c49f0c59 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Backprop step of CudnnRNNV3.
@@ -82,7 +82,7 @@
  * 
  * @param <T> data type for {@code inputBackprop()} output
  */
-public final class CudnnRNNBackprop<T extends TNumber> extends RawOp {
+public final class CudnnRNNBackprop<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNBackprop}
@@ -187,7 +187,7 @@ private Options() {
    * @return a new instance of CudnnRNNBackprop
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CudnnRNNBackprop<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Operand<T> output, Operand<T> outputH, Operand<T> outputC, Operand<T> outputBackprop, Operand<T> outputHBackprop, Operand<T> outputCBackprop, Operand<T> reserveSpace, Operand<?> hostReserved, Options... options) {
+  public static <T extends Tensor & TNumber> CudnnRNNBackprop<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Operand<T> output, Operand<T> outputH, Operand<T> outputC, Operand<T> outputBackprop, Operand<T> outputHBackprop, Operand<T> outputCBackprop, Operand<T> reserveSpace, Operand<?> hostReserved, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNBackpropV3", scope.makeOpName("CudnnRNNBackprop"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputH.asOutput());
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 945fdacdf62..d1cf41a5038 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
@@ -21,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -28,7 +29,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts CudnnRNN params from canonical form to usable form. It supports the projection in LSTM.
@@ -67,7 +67,7 @@
  * @param <T> data type for {@code params()} output
  */
 @Operator(group = "nn")
-public final class CudnnRNNCanonicalToParams<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CudnnRNNCanonicalToParams<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNCanonicalToParams}
@@ -155,7 +155,7 @@ private Options() {
    * @return a new instance of CudnnRNNCanonicalToParams
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CudnnRNNCanonicalToParams<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Iterable<Operand<T>> weights, Iterable<Operand<T>> biases, Options... options) {
+  public static <T extends Tensor & TNumber> CudnnRNNCanonicalToParams<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Iterable<Operand<T>> weights, Iterable<Operand<T>> biases, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNCanonicalToParamsV2", scope.makeOpName("CudnnRNNCanonicalToParams"));
     opBuilder.addInput(numLayers.asOutput());
     opBuilder.addInput(numUnits.asOutput());
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 e7fbeebf99f..e9342852933 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Retrieves CudnnRNN params in canonical form. It supports the projection in LSTM.
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code weights()} output
  */
 @Operator(group = "nn")
-public final class CudnnRNNParamsToCanonical<T extends TNumber> extends RawOp {
+public final class CudnnRNNParamsToCanonical<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNParamsToCanonical}
@@ -157,7 +157,7 @@ private Options() {
    * @return a new instance of CudnnRNNParamsToCanonical
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CudnnRNNParamsToCanonical<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Operand<T> params, Long numParamsWeights, Long numParamsBiases, Options... options) {
+  public static <T extends Tensor & TNumber> CudnnRNNParamsToCanonical<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Operand<T> params, Long numParamsWeights, Long numParamsBiases, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNParamsToCanonicalV2", scope.makeOpName("CudnnRNNParamsToCanonical"));
     opBuilder.addInput(numLayers.asOutput());
     opBuilder.addInput(numUnits.asOutput());
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 6cff6fe9836..753c35f4fec 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes size of weights that can be used by a Cudnn RNN model.
@@ -58,7 +58,7 @@
  * @param <U> data type for {@code paramsSize()} output
  */
 @Operator(group = "nn")
-public final class CudnnRnnParamsSize<U extends TNumber> extends RawOp implements Operand<U> {
+public final class CudnnRnnParamsSize<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRnnParamsSize}
@@ -146,7 +146,7 @@ private Options() {
    * @return a new instance of CudnnRnnParamsSize
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> CudnnRnnParamsSize<U> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, DataType<T> T, DataType<U> S, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> CudnnRnnParamsSize<U> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, DataType<T> T, DataType<U> S, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNParamsSize", scope.makeOpName("CudnnRnnParamsSize"));
     opBuilder.addInput(numLayers.asOutput());
     opBuilder.addInput(numUnits.asOutput());
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 eb82df7184c..b0684f2462b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the dimension index in the destination data format given the one in
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class DataFormatDimMap<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DataFormatDimMap<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DataFormatDimMap}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of DataFormatDimMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DataFormatDimMap<T> create(Scope scope, Operand<T> x, Options... options) {
+  public static <T extends Tensor & TNumber> DataFormatDimMap<T> create(Scope scope, Operand<T> x, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DataFormatDimMap", scope.makeOpName("DataFormatDimMap"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 5a04c0847c7..b7aa7357ff6 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the permuted vector/tensor in the destination data format given the
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class DataFormatVecPermute<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DataFormatVecPermute<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DataFormatVecPermute}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of DataFormatVecPermute
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DataFormatVecPermute<T> create(Scope scope, Operand<T> x, Options... options) {
+  public static <T extends Tensor & TNumber> DataFormatVecPermute<T> create(Scope scope, Operand<T> x, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DataFormatVecPermute", scope.makeOpName("DataFormatVecPermute"));
     opBuilder.addInput(x.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 523977a1db0..94085de3dda 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * DepthToSpace for tensors of type T.
@@ -113,7 +113,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthToSpace<T extends TType> extends RawOp implements Operand<T> {
+public final class DepthToSpace<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthToSpace}
@@ -144,7 +144,7 @@ private Options() {
    * @return a new instance of DepthToSpace
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DepthToSpace<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
+  public static <T extends Tensor> DepthToSpace<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthToSpace", scope.makeOpName("DepthToSpace"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 36277e498d5..21045735cc0 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors.
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNative<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DepthwiseConv2dNative<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNative}
@@ -103,7 +103,7 @@ private Options() {
    * @return a new instance of DepthwiseConv2dNative
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DepthwiseConv2dNative<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> DepthwiseConv2dNative<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthwiseConv2dNative", scope.makeOpName("DepthwiseConv2dNative"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 074d37aba9b..bd49bd1525a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradients of depthwise convolution with respect to the filter.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNativeBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DepthwiseConv2dNativeBackpropFilter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNativeBackpropFilter}
@@ -95,7 +95,7 @@ private Options() {
    * @return a new instance of DepthwiseConv2dNativeBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DepthwiseConv2dNativeBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthwiseConv2dNativeBackpropFilter", scope.makeOpName("DepthwiseConv2dNativeBackpropFilter"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filterSizes.asOutput());
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 323890cbc1e..c61e9f23c55 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradients of depthwise convolution with respect to the input.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNativeBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
+public final class DepthwiseConv2dNativeBackpropInput<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNativeBackpropInput}
@@ -94,7 +94,7 @@ private Options() {
    * @return a new instance of DepthwiseConv2dNativeBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> DepthwiseConv2dNativeBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthwiseConv2dNativeBackpropInput", scope.makeOpName("DepthwiseConv2dNativeBackpropInput"));
     opBuilder.addInput(inputSizes.asOutput());
     opBuilder.addInput(filter.asOutput());
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 984c4621881..364aaf593ba 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the grayscale dilation of 4-D `input` and 3-D `filter` tensors.
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Dilation2d<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Dilation2d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dilation2d operation.
@@ -75,7 +75,7 @@ public final class Dilation2d<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of Dilation2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Dilation2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends Tensor & TNumber> Dilation2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dilation2D", scope.makeOpName("Dilation2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 1e413d9a08c..1456056f66e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of morphological 2-D dilation with respect to the filter.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code filterBackprop()} output
  */
 @Operator(group = "nn")
-public final class Dilation2dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Dilation2dBackpropFilter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dilation2dBackpropFilter operation.
@@ -52,7 +52,7 @@ public final class Dilation2dBackpropFilter<T extends TNumber> extends RawOp imp
    * @return a new instance of Dilation2dBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Dilation2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends Tensor & TNumber> Dilation2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dilation2DBackpropFilter", scope.makeOpName("Dilation2dBackpropFilter"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 7d247c4288b..5b64c67344c 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of morphological 2-D dilation with respect to the input.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code inBackprop()} output
  */
 @Operator(group = "nn")
-public final class Dilation2dBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Dilation2dBackpropInput<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dilation2dBackpropInput operation.
@@ -52,7 +52,7 @@ public final class Dilation2dBackpropInput<T extends TNumber> extends RawOp impl
    * @return a new instance of Dilation2dBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Dilation2dBackpropInput<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends Tensor & TNumber> Dilation2dBackpropInput<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dilation2DBackpropInput", scope.makeOpName("Dilation2dBackpropInput"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 f138ee46ce3..199dabaf52d 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes exponential linear: `exp(features) - 1` if < 0, `features` otherwise.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Elu<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Elu<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Elu operation.
@@ -47,7 +47,7 @@ public final class Elu<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Elu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Elu<T> create(Scope scope, Operand<T> features) {
+  public static <T extends Tensor & TNumber> Elu<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Elu", scope.makeOpName("Elu"));
     opBuilder.addInput(features.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 fd41f261813..d53fc754996 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients for the exponential linear (Elu) operation.
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class EluGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class EluGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new EluGrad operation.
@@ -44,7 +44,7 @@ public final class EluGrad<T extends TNumber> extends RawOp implements Operand<T
    * @return a new instance of EluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> EluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
+  public static <T extends Tensor & TNumber> EluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("EluGrad", scope.makeOpName("EluGrad"));
     opBuilder.addInput(gradients.asOutput());
     opBuilder.addInput(outputs.asOutput());
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 189f1b9c27c..fb25c90796a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs fractional average pooling on the input.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FractionalAvgPool<T extends TNumber> extends RawOp {
+public final class FractionalAvgPool<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalAvgPool}
@@ -128,7 +128,7 @@ private Options() {
    * @return a new instance of FractionalAvgPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FractionalAvgPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
+  public static <T extends Tensor & TNumber> FractionalAvgPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalAvgPool", scope.makeOpName("FractionalAvgPool"));
     opBuilder.addInput(value.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 26c06215c54..858d75fd13b 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradient of the FractionalAvgPool function.
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class FractionalAvgPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class FractionalAvgPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalAvgPoolGrad}
@@ -84,7 +84,7 @@ private Options() {
    * @return a new instance of FractionalAvgPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FractionalAvgPoolGrad<T> create(Scope scope, Operand<TInt64> origInputTensorShape, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
+  public static <T extends Tensor & TNumber> FractionalAvgPoolGrad<T> create(Scope scope, Operand<TInt64> origInputTensorShape, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalAvgPoolGrad", scope.makeOpName("FractionalAvgPoolGrad"));
     opBuilder.addInput(origInputTensorShape.asOutput());
     opBuilder.addInput(outBackprop.asOutput());
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 015b99a14eb..a243ac7ef0a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs fractional max pooling on the input.
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FractionalMaxPool<T extends TNumber> extends RawOp {
+public final class FractionalMaxPool<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalMaxPool}
@@ -152,7 +152,7 @@ private Options() {
    * @return a new instance of FractionalMaxPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FractionalMaxPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
+  public static <T extends Tensor & TNumber> FractionalMaxPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalMaxPool", scope.makeOpName("FractionalMaxPool"));
     opBuilder.addInput(value.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 cabbf2e038a..b1290e0096f 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,20 +21,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradient of the FractionalMaxPool function.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class FractionalMaxPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class FractionalMaxPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalMaxPoolGrad}
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of FractionalMaxPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FractionalMaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
+  public static <T extends Tensor & TNumber> FractionalMaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalMaxPoolGrad", scope.makeOpName("FractionalMaxPoolGrad"));
     opBuilder.addInput(origInput.asOutput());
     opBuilder.addInput(origOutput.asOutput());
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 464ae92f2ae..e87464074e9 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Batch normalization.
@@ -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 RawOp {
+public final class FusedBatchNorm<T extends Tensor & TNumber, U extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedBatchNorm}
@@ -102,7 +102,7 @@ private Options() {
    * @return a new instance of FusedBatchNorm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> FusedBatchNorm<T, U> create(Scope scope, Operand<T> x, Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNorm<T, U> create(Scope scope, Operand<T> x, Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedBatchNormV3", scope.makeOpName("FusedBatchNorm"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(scale.asOutput());
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 52bd5e98084..4cc599672c2 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gradient for batch normalization.
@@ -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 RawOp {
+public final class FusedBatchNormGrad<T extends Tensor & TNumber, U extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedBatchNormGrad}
@@ -103,7 +103,7 @@ private Options() {
    * @return a new instance of FusedBatchNormGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> FusedBatchNormGrad<T, U> create(Scope scope, Operand<T> yBackprop, Operand<T> x, Operand<TFloat32> scale, Operand<U> reserveSpace1, Operand<U> reserveSpace2, Operand<U> reserveSpace3, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNormGrad<T, U> create(Scope scope, Operand<T> yBackprop, Operand<T> x, Operand<TFloat32> scale, Operand<U> reserveSpace1, Operand<U> reserveSpace2, Operand<U> reserveSpace3, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedBatchNormGradV3", scope.makeOpName("FusedBatchNormGrad"));
     opBuilder.addInput(yBackprop.asOutput());
     opBuilder.addInput(x.asOutput());
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 11ec154a076..59761847b9d 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs a padding as a preprocess during a convolution.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FusedPadConv2d<T extends TNumber> extends RawOp implements Operand<T> {
+public final class FusedPadConv2d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FusedPadConv2d operation.
@@ -66,7 +66,7 @@ public final class FusedPadConv2d<T extends TNumber> extends RawOp implements Op
    * @return a new instance of FusedPadConv2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FusedPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding) {
+  public static <T extends Tensor & TNumber> FusedPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedPadConv2D", scope.makeOpName("FusedPadConv2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(paddings.asOutput());
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 4eda6e97eaa..4df54a3e2ab 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs a resize and padding as a preprocess during a convolution.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FusedResizeAndPadConv2d<T extends TNumber> extends RawOp implements Operand<T> {
+public final class FusedResizeAndPadConv2d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedResizeAndPadConv2d}
@@ -88,7 +88,7 @@ private Options() {
    * @return a new instance of FusedResizeAndPadConv2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> FusedResizeAndPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> FusedResizeAndPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedResizeAndPadConv2D", scope.makeOpName("FusedResizeAndPadConv2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(size.asOutput());
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 49c7d619410..aef0518ba41 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the GRU cell forward propagation for 1 time step.
@@ -78,7 +78,7 @@
  * 
  * @param <T> data type for {@code r()} output
  */
-public final class GRUBlockCell<T extends TNumber> extends RawOp {
+public final class GRUBlockCell<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new GRUBlockCell operation.
@@ -93,7 +93,7 @@ public final class GRUBlockCell<T extends TNumber> extends RawOp {
    * @return a new instance of GRUBlockCell
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> GRUBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC) {
+  public static <T extends Tensor & TNumber> GRUBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC) {
     OperationBuilder opBuilder = scope.env().opBuilder("GRUBlockCell", scope.makeOpName("GRUBlockCell"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(hPrev.asOutput());
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 bea3442c6c9..b971b3afb62 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the GRU cell back-propagation for 1 time step.
@@ -114,7 +114,7 @@
  * 
  * @param <T> data type for {@code dX()} output
  */
-public final class GRUBlockCellGrad<T extends TNumber> extends RawOp {
+public final class GRUBlockCellGrad<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new GRUBlockCellGrad operation.
@@ -133,7 +133,7 @@ public final class GRUBlockCellGrad<T extends TNumber> extends RawOp {
    * @return a new instance of GRUBlockCellGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> GRUBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC, Operand<T> r, Operand<T> u, Operand<T> c, Operand<T> dH) {
+  public static <T extends Tensor & TNumber> GRUBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC, Operand<T> r, Operand<T> u, Operand<T> c, Operand<T> dH) {
     OperationBuilder opBuilder = scope.env().opBuilder("GRUBlockCellGrad", scope.makeOpName("GRUBlockCellGrad"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(hPrev.asOutput());
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 1255067ed44..2a1a9aff9ca 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Says whether the targets are in the top `K` predictions.
@@ -61,7 +61,7 @@ public final class InTopK extends RawOp implements Operand<TBool> {
    * @return a new instance of InTopK
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> InTopK create(Scope scope, Operand<TFloat32> predictions, Operand<T> targets, Operand<T> k) {
+  public static <T extends Tensor & TNumber> InTopK create(Scope scope, Operand<TFloat32> predictions, Operand<T> targets, Operand<T> k) {
     OperationBuilder opBuilder = scope.env().opBuilder("InTopKV2", scope.makeOpName("InTopK"));
     opBuilder.addInput(predictions.asOutput());
     opBuilder.addInput(targets.asOutput());
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 b0df0c43ee0..e4c358a2481 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the inverse of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class InvGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class InvGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InvGrad operation.
@@ -46,7 +46,7 @@ public final class InvGrad<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of InvGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> InvGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends Tensor> InvGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("InvGrad", scope.makeOpName("InvGrad"));
     opBuilder.addInput(y.asOutput());
     opBuilder.addInput(dy.asOutput());
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 91d141c787c..04542e7117a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * L2 Loss.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class L2Loss<T extends TNumber> extends RawOp implements Operand<T> {
+public final class L2Loss<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new L2Loss operation.
@@ -48,7 +48,7 @@ public final class L2Loss<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of L2Loss
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> L2Loss<T> create(Scope scope, Operand<T> t) {
+  public static <T extends Tensor & TNumber> L2Loss<T> create(Scope scope, Operand<T> t) {
     OperationBuilder opBuilder = scope.env().opBuilder("L2Loss", scope.makeOpName("L2Loss"));
     opBuilder.addInput(t.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 a10d335bc0b..3bbf9690e13 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the LSTM cell forward propagation for 1 time step.
@@ -58,7 +58,7 @@
  * 
  * @param <T> data type for {@code i()} output
  */
-public final class LSTMBlockCell<T extends TNumber> extends RawOp {
+public final class LSTMBlockCell<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LSTMBlockCell}
@@ -113,7 +113,7 @@ private Options() {
    * @return a new instance of LSTMBlockCell
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LSTMBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
+  public static <T extends Tensor & TNumber> LSTMBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LSTMBlockCell", scope.makeOpName("LSTMBlockCell"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(csPrev.asOutput());
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 bfb5dae0118..f3c8a9d2823 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the LSTM cell backward propagation for 1 timestep.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code csPrevGrad()} output
  */
-public final class LSTMBlockCellGrad<T extends TNumber> extends RawOp {
+public final class LSTMBlockCellGrad<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LSTMBlockCellGrad operation.
@@ -61,7 +61,7 @@ public final class LSTMBlockCellGrad<T extends TNumber> extends RawOp {
    * @return a new instance of LSTMBlockCellGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LSTMBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
+  public static <T extends Tensor & TNumber> LSTMBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
     OperationBuilder opBuilder = scope.env().opBuilder("LSTMBlockCellGrad", scope.makeOpName("LSTMBlockCellGrad"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(csPrev.asOutput());
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 54579426b78..c9e9c98be21 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes rectified linear: `max(features, features * alpha)`.
  * 
  * @param <T> data type for {@code activations()} output
  */
-public final class LeakyRelu<T extends TNumber> extends RawOp implements Operand<T> {
+public final class LeakyRelu<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LeakyRelu}
@@ -63,7 +63,7 @@ private Options() {
    * @return a new instance of LeakyRelu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LeakyRelu<T> create(Scope scope, Operand<T> features, Options... options) {
+  public static <T extends Tensor & TNumber> LeakyRelu<T> create(Scope scope, Operand<T> features, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LeakyRelu", scope.makeOpName("LeakyRelu"));
     opBuilder.addInput(features.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 0004fed685b..823731dca6b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Local Response Normalization.
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class LocalResponseNormalization<T extends TNumber> extends RawOp implements Operand<T> {
+public final class LocalResponseNormalization<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LocalResponseNormalization}
@@ -103,7 +103,7 @@ private Options() {
    * @return a new instance of LocalResponseNormalization
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LocalResponseNormalization<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor & TNumber> LocalResponseNormalization<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LRN", scope.makeOpName("LocalResponseNormalization"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 24d769e571a..8c15dbb937c 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gradients for Local Response Normalization.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class LocalResponseNormalizationGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class LocalResponseNormalizationGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LocalResponseNormalizationGrad}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of LocalResponseNormalizationGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LocalResponseNormalizationGrad<T> create(Scope scope, Operand<T> inputGrads, Operand<T> inputImage, Operand<T> outputImage, Options... options) {
+  public static <T extends Tensor & TNumber> LocalResponseNormalizationGrad<T> create(Scope scope, Operand<T> inputGrads, Operand<T> inputImage, Operand<T> outputImage, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LRNGrad", scope.makeOpName("LocalResponseNormalizationGrad"));
     opBuilder.addInput(inputGrads.asOutput());
     opBuilder.addInput(inputImage.asOutput());
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 58035248560..e2bdf72d1ff 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes log softmax activations.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code logsoftmax()} output
  */
 @Operator(group = "nn")
-public final class LogSoftmax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class LogSoftmax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new LogSoftmax operation.
@@ -48,7 +48,7 @@ public final class LogSoftmax<T extends TNumber> extends RawOp implements Operan
    * @return a new instance of LogSoftmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> LogSoftmax<T> create(Scope scope, Operand<T> logits) {
+  public static <T extends Tensor & TNumber> LogSoftmax<T> create(Scope scope, Operand<T> logits) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogSoftmax", scope.makeOpName("LogSoftmax"));
     opBuilder.addInput(logits.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 4df68034706..1f04b7e6365 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs max pooling on the input.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool<T extends TType> extends RawOp implements Operand<T> {
+public final class MaxPool<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool}
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of MaxPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> MaxPool<T> create(Scope scope, Operand<T> input, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
+  public static <T extends Tensor> MaxPool<T> create(Scope scope, Operand<T> input, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolV2", scope.makeOpName("MaxPool"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(ksize.asOutput());
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 c38fd7b341e..9718086f92f 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs 3D max pooling on the input.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3d<T extends TNumber> extends RawOp implements Operand<T> {
+public final class MaxPool3d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3d}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of MaxPool3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> MaxPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> MaxPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPool3D", scope.makeOpName("MaxPool3d"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 8361c38b80a..5fc4ee59e7a 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients of max pooling function.
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3dGrad<U extends TNumber> extends RawOp implements Operand<U> {
+public final class MaxPool3dGrad<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3dGrad}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of MaxPool3dGrad
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> MaxPool3dGrad<U> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<U> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> MaxPool3dGrad<U> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<U> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPool3DGrad", scope.makeOpName("MaxPool3dGrad"));
     opBuilder.addInput(origInput.asOutput());
     opBuilder.addInput(origOutput.asOutput());
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 93407692efa..1e823be32df 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes second-order gradients of the maxpooling function.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3dGradGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class MaxPool3dGradGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3dGradGrad}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of MaxPool3dGradGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> MaxPool3dGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> MaxPool3dGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPool3DGradGrad", scope.makeOpName("MaxPool3dGradGrad"));
     opBuilder.addInput(origInput.asOutput());
     opBuilder.addInput(origOutput.asOutput());
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 7db3693e736..ef85953d548 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients of the maxpooling function.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGrad}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of MaxPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> MaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> MaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradV2", scope.makeOpName("MaxPoolGrad"));
     opBuilder.addInput(origInput.asOutput());
     opBuilder.addInput(origOutput.asOutput());
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 9fee7af4c0e..28547d8e884 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes second-order gradients of the maxpooling function.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGradGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGradGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradGrad}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of MaxPoolGradGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> MaxPoolGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> MaxPoolGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradGradV2", scope.makeOpName("MaxPoolGradGrad"));
     opBuilder.addInput(origInput.asOutput());
     opBuilder.addInput(origOutput.asOutput());
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 232f2ec18a8..5f170c69a4e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes second-order gradients of the maxpooling function.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGradGradWithArgmax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGradGradWithArgmax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradGradWithArgmax}
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of MaxPoolGradGradWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> MaxPoolGradGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolGradGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradGradWithArgmax", scope.makeOpName("MaxPoolGradGradWithArgmax"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(grad.asOutput());
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 8d1aa1da798..c479a42d739 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients of the maxpooling function.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MaxPoolGradWithArgmax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGradWithArgmax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradWithArgmax}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of MaxPoolGradWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> MaxPoolGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradWithArgmax", scope.makeOpName("MaxPoolGradWithArgmax"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(grad.asOutput());
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 4eeb66cbc68..9928fa6e17e 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Performs max pooling on the input and outputs both max values and indices.
@@ -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 RawOp {
+public final class MaxPoolWithArgmax<T extends Tensor & TNumber, U extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolWithArgmax}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of MaxPoolWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> MaxPoolWithArgmax<T, U> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, DataType<U> Targmax, String padding, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolWithArgmax<T, U> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, DataType<U> Targmax, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolWithArgmax", scope.makeOpName("MaxPoolWithArgmax"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -122,7 +122,7 @@ public static <T extends TNumber, U extends TNumber> MaxPoolWithArgmax<T, U> cre
    * @return a new instance of MaxPoolWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> MaxPoolWithArgmax<T, TInt64> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends Tensor & TNumber> MaxPoolWithArgmax<T, TInt64> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     return create(scope, input, ksize, strides, TInt64.DTYPE, padding, options);
   }
   
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 cf379fa5ecf..2fc9ea59b4b 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Finds values of the `n`-th order statistic for the last dimension.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "nn")
-public final class NthElement<T extends TNumber> extends RawOp implements Operand<T> {
+public final class NthElement<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.NthElement}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of NthElement
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> NthElement<T> create(Scope scope, Operand<T> input, Operand<TInt32> n, Options... options) {
+  public static <T extends Tensor & TNumber> NthElement<T> create(Scope scope, Operand<T> input, Operand<TInt32> n, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("NthElement", scope.makeOpName("NthElement"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(n.asOutput());
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 9ac24133f7c..e2f2a4b2764 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Produces the average pool of the input tensor for quantized types.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedAvgPool<T extends TType> extends RawOp {
+public final class QuantizedAvgPool<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedAvgPool operation.
@@ -52,7 +52,7 @@ public final class QuantizedAvgPool<T extends TType> extends RawOp {
    * @return a new instance of QuantizedAvgPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> QuantizedAvgPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
+  public static <T extends Tensor> QuantizedAvgPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedAvgPool", scope.makeOpName("QuantizedAvgPool"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(minInput.asOutput());
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 dd5b716b401..9d828d27e25 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Quantized Batch normalization.
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code result()} output
  */
 @Operator(group = "nn")
-public final class QuantizedBatchNormWithGlobalNormalization<U extends TType> extends RawOp {
+public final class QuantizedBatchNormWithGlobalNormalization<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedBatchNormWithGlobalNormalization operation.
@@ -73,7 +73,7 @@ public final class QuantizedBatchNormWithGlobalNormalization<U extends TType> ex
    * @return a new instance of QuantizedBatchNormWithGlobalNormalization
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> QuantizedBatchNormWithGlobalNormalization<U> create(Scope scope, Operand<T> t, Operand<TFloat32> tMin, Operand<TFloat32> tMax, Operand<T> m, Operand<TFloat32> mMin, Operand<TFloat32> mMax, Operand<T> v, Operand<TFloat32> vMin, Operand<TFloat32> vMax, Operand<T> beta, Operand<TFloat32> betaMin, Operand<TFloat32> betaMax, Operand<T> gamma, Operand<TFloat32> gammaMin, Operand<TFloat32> gammaMax, DataType<U> outType, Float varianceEpsilon, Boolean scaleAfterNormalization) {
+  public static <U extends Tensor, T extends Tensor> QuantizedBatchNormWithGlobalNormalization<U> create(Scope scope, Operand<T> t, Operand<TFloat32> tMin, Operand<TFloat32> tMax, Operand<T> m, Operand<TFloat32> mMin, Operand<TFloat32> mMax, Operand<T> v, Operand<TFloat32> vMin, Operand<TFloat32> vMax, Operand<T> beta, Operand<TFloat32> betaMin, Operand<TFloat32> betaMax, Operand<T> gamma, Operand<TFloat32> gammaMin, Operand<TFloat32> gammaMax, DataType<U> outType, Float varianceEpsilon, Boolean scaleAfterNormalization) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedBatchNormWithGlobalNormalization", scope.makeOpName("QuantizedBatchNormWithGlobalNormalization"));
     opBuilder.addInput(t.asOutput());
     opBuilder.addInput(tMin.asOutput());
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 818c4455ac5..5346b495296 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds Tensor 'bias' to Tensor 'input' for Quantized types.
@@ -37,7 +37,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedBiasAdd<V extends TType> extends RawOp {
+public final class QuantizedBiasAdd<V extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedBiasAdd operation.
@@ -53,7 +53,7 @@ public final class QuantizedBiasAdd<V extends TType> extends RawOp {
    * @return a new instance of QuantizedBiasAdd
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedBiasAdd<V> create(Scope scope, Operand<T> input, Operand<U> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minBias, Operand<TFloat32> maxBias, DataType<V> outType) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedBiasAdd<V> create(Scope scope, Operand<T> input, Operand<U> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minBias, Operand<TFloat32> maxBias, DataType<V> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedBiasAdd", scope.makeOpName("QuantizedBiasAdd"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(bias.asOutput());
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 f1258c3ac71..073fbc605d5 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndRelu<V extends TType> extends RawOp {
+public final class QuantizedConv2DAndRelu<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndRelu}
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DAndRelu", scope.makeOpName("QuantizedConv2DAndRelu"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 9a763e629d9..ebcaa853bd9 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndReluAndRequantize<V extends TType> extends RawOp {
+public final class QuantizedConv2DAndReluAndRequantize<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndReluAndRequantize}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DAndReluAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DAndReluAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DAndReluAndRequantize", scope.makeOpName("QuantizedConv2DAndReluAndRequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 ac1ca66f079..4b1e3547259 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndRequantize<V extends TType> extends RawOp {
+public final class QuantizedConv2DAndRequantize<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndRequantize}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DAndRequantize", scope.makeOpName("QuantizedConv2DAndRequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 da2dfa6e491..4eb5c4c0d8d 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes QuantizedConv2D per channel.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DPerChannel<V extends TType> extends RawOp {
+public final class QuantizedConv2DPerChannel<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DPerChannel}
@@ -73,7 +73,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DPerChannel
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DPerChannel<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DPerChannel<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DPerChannel", scope.makeOpName("QuantizedConv2DPerChannel"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 da843bf735a..9c3e4469d2f 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBias<V extends TType> extends RawOp {
+public final class QuantizedConv2DWithBias<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBias}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBias
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBias", scope.makeOpName("QuantizedConv2DWithBias"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 6176626745d..d268bb0e2f9 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndRelu<V extends TType> extends RawOp {
+public final class QuantizedConv2DWithBiasAndRelu<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndRelu}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasAndRelu", scope.makeOpName("QuantizedConv2DWithBiasAndRelu"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 d6700e175a5..287500aa5cf 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
+public final class QuantizedConv2DWithBiasAndReluAndRequantize<W extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndReluAndRequantize}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
+  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasAndReluAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasAndReluAndRequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 7f8d24095e4..226ec21d882 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndRequantize<W extends TType> extends RawOp {
+public final class QuantizedConv2DWithBiasAndRequantize<W extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndRequantize}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedConv2DWithBiasAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
+  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedConv2DWithBiasAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasAndRequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 cc3d6cc73dc..0c79a3775ab 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <X> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X extends TType> extends RawOp {
+public final class QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSignedSumAndReluAndRequantize}
@@ -86,7 +86,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasSignedSumAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <X extends TType, T extends TType, U extends TType, V extends TType, W extends TType> QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
+  public static <X extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor, W extends Tensor> QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 69759e0bc8a..5bf9491abe5 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSumAndRelu<V extends TType> extends RawOp {
+public final class QuantizedConv2DWithBiasSumAndRelu<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSumAndRelu}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasSumAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DWithBiasSumAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> summand, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DWithBiasSumAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> summand, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasSumAndRelu", scope.makeOpName("QuantizedConv2DWithBiasSumAndRelu"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 e6d03b99188..c0562b0ee30 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <X> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSumAndReluAndRequantize<X extends TType> extends RawOp {
+public final class QuantizedConv2DWithBiasSumAndReluAndRequantize<X extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSumAndReluAndRequantize}
@@ -86,7 +86,7 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasSumAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <X extends TType, T extends TType, U extends TType, V extends TType, W extends TType> QuantizedConv2DWithBiasSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
+  public static <X extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor, W extends Tensor> QuantizedConv2DWithBiasSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasSumAndReluAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasSumAndReluAndRequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 c791a624c51..8f7a03b0bf0 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes a 2D convolution given quantized 4D input and filter tensors.
@@ -41,7 +41,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedConv2d<V extends TType> extends RawOp {
+public final class QuantizedConv2d<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2d}
@@ -84,7 +84,7 @@ private Options() {
    * @return a new instance of QuantizedConv2d
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2d<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2d<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2D", scope.makeOpName("QuantizedConv2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 2145de9c8eb..2ba5d7611ab 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2D<V extends TType> extends RawOp {
+public final class QuantizedDepthwiseConv2D<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2D}
@@ -73,7 +73,7 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2D
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedDepthwiseConv2D<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedDepthwiseConv2D<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2D", scope.makeOpName("QuantizedDepthwiseConv2D"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 5aa0d466d0e..b7aea60289a 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D with Bias.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBias<V extends TType> extends RawOp {
+public final class QuantizedDepthwiseConv2DWithBias<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBias}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2DWithBias
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedDepthwiseConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedDepthwiseConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2DWithBias", scope.makeOpName("QuantizedDepthwiseConv2DWithBias"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 46e628f2c29..3a0e049107e 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D with Bias and Relu.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBiasAndRelu<V extends TType> extends RawOp {
+public final class QuantizedDepthwiseConv2DWithBiasAndRelu<V extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBiasAndRelu}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2DWithBiasAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TType, T extends TType, U extends TType> QuantizedDepthwiseConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedDepthwiseConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2DWithBiasAndRelu", scope.makeOpName("QuantizedDepthwiseConv2DWithBiasAndRelu"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 3a13eaaa567..57526c6554f 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D with Bias, Relu and Requantize.
  * 
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
+public final class QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize}
@@ -85,7 +85,7 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
+  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", scope.makeOpName("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(filter.asOutput());
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 ba393889984..2f0fa6e14bb 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Quantized Instance normalization.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class QuantizedInstanceNorm<T extends TType> extends RawOp {
+public final class QuantizedInstanceNorm<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedInstanceNorm}
@@ -104,7 +104,7 @@ private Options() {
    * @return a new instance of QuantizedInstanceNorm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> QuantizedInstanceNorm<T> create(Scope scope, Operand<T> x, Operand<TFloat32> xMin, Operand<TFloat32> xMax, Options... options) {
+  public static <T extends Tensor> QuantizedInstanceNorm<T> create(Scope scope, Operand<T> x, Operand<TFloat32> xMin, Operand<TFloat32> xMax, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedInstanceNorm", scope.makeOpName("QuantizedInstanceNorm"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(xMin.asOutput());
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 94c00253cc5..3c60462ef7e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Produces the max pool of the input tensor for quantized types.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedMaxPool<T extends TType> extends RawOp {
+public final class QuantizedMaxPool<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedMaxPool operation.
@@ -52,7 +52,7 @@ public final class QuantizedMaxPool<T extends TType> extends RawOp {
    * @return a new instance of QuantizedMaxPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> QuantizedMaxPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
+  public static <T extends Tensor> QuantizedMaxPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMaxPool", scope.makeOpName("QuantizedMaxPool"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(minInput.asOutput());
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 9c9407e0b9a..a9c1db94a6a 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes Quantized Rectified Linear: `max(features, 0)`
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedRelu<U extends TType> extends RawOp {
+public final class QuantizedRelu<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedRelu operation.
@@ -48,7 +48,7 @@ public final class QuantizedRelu<U extends TType> extends RawOp {
    * @return a new instance of QuantizedRelu
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> QuantizedRelu<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> QuantizedRelu<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedRelu", scope.makeOpName("QuantizedRelu"));
     opBuilder.addInput(features.asOutput());
     opBuilder.addInput(minFeatures.asOutput());
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 150ec50779e..8c617c5ed5e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedRelu6<U extends TType> extends RawOp {
+public final class QuantizedRelu6<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedRelu6 operation.
@@ -48,7 +48,7 @@ public final class QuantizedRelu6<U extends TType> extends RawOp {
    * @return a new instance of QuantizedRelu6
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> QuantizedRelu6<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> QuantizedRelu6<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedRelu6", scope.makeOpName("QuantizedRelu6"));
     opBuilder.addInput(features.asOutput());
     opBuilder.addInput(minFeatures.asOutput());
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 2d446c3a45d..4a0431627de 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedReluX<U extends TType> extends RawOp {
+public final class QuantizedReluX<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedReluX operation.
@@ -49,7 +49,7 @@ public final class QuantizedReluX<U extends TType> extends RawOp {
    * @return a new instance of QuantizedReluX
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> QuantizedReluX<U> create(Scope scope, Operand<T> features, Operand<TFloat32> maxValue, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> QuantizedReluX<U> create(Scope scope, Operand<T> features, Operand<TFloat32> maxValue, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedReluX", scope.makeOpName("QuantizedReluX"));
     opBuilder.addInput(features.asOutput());
     opBuilder.addInput(maxValue.asOutput());
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 2facaa697ec..6510aa66cfc 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes rectified linear: `max(features, 0)`.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Relu<T extends TType> extends RawOp implements Operand<T> {
+public final class Relu<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Relu operation.
@@ -48,7 +48,7 @@ public final class Relu<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Relu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Relu<T> create(Scope scope, Operand<T> features) {
+  public static <T extends Tensor> Relu<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Relu", scope.makeOpName("Relu"));
     opBuilder.addInput(features.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 f32eb410f00..f4003710db2 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes rectified linear 6: `min(max(features, 0), 6)`.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Relu6<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Relu6<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Relu6 operation.
@@ -44,7 +44,7 @@ public final class Relu6<T extends TNumber> extends RawOp implements Operand<T>
    * @return a new instance of Relu6
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Relu6<T> create(Scope scope, Operand<T> features) {
+  public static <T extends Tensor & TNumber> Relu6<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Relu6", scope.makeOpName("Relu6"));
     opBuilder.addInput(features.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 7cd8e3197e6..e3b952604c1 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes rectified linear 6 gradients for a Relu6 operation.
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class Relu6Grad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Relu6Grad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Relu6Grad operation.
@@ -45,7 +45,7 @@ public final class Relu6Grad<T extends TNumber> extends RawOp implements Operand
    * @return a new instance of Relu6Grad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Relu6Grad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends Tensor & TNumber> Relu6Grad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Relu6Grad", scope.makeOpName("Relu6Grad"));
     opBuilder.addInput(gradients.asOutput());
     opBuilder.addInput(features.asOutput());
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 c467c606b69..ab3a54f6d05 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes rectified linear gradients for a Relu operation.
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class ReluGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ReluGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ReluGrad operation.
@@ -45,7 +45,7 @@ public final class ReluGrad<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of ReluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends Tensor & TNumber> ReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReluGrad", scope.makeOpName("ReluGrad"));
     opBuilder.addInput(gradients.asOutput());
     opBuilder.addInput(features.asOutput());
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 dae469aa5a3..dc5ce9c8818 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes scaled exponential linear: `scale * alpha * (exp(features) - 1)`
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Selu<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Selu<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Selu operation.
@@ -52,7 +52,7 @@ public final class Selu<T extends TNumber> extends RawOp implements Operand<T> {
    * @return a new instance of Selu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Selu<T> create(Scope scope, Operand<T> features) {
+  public static <T extends Tensor & TNumber> Selu<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Selu", scope.makeOpName("Selu"));
     opBuilder.addInput(features.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 91389503235..4f225f53e4f 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients for the scaled exponential linear (Selu) operation.
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SeluGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SeluGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SeluGrad operation.
@@ -44,7 +44,7 @@ public final class SeluGrad<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of SeluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SeluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
+  public static <T extends Tensor & TNumber> SeluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("SeluGrad", scope.makeOpName("SeluGrad"));
     opBuilder.addInput(gradients.asOutput());
     opBuilder.addInput(outputs.asOutput());
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 c1744627645..1d8da60bc7f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes softmax activations.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code softmax()} output
  */
 @Operator(group = "nn")
-public final class Softmax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Softmax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Softmax operation.
@@ -48,7 +48,7 @@ public final class Softmax<T extends TNumber> extends RawOp implements Operand<T
    * @return a new instance of Softmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Softmax<T> create(Scope scope, Operand<T> logits) {
+  public static <T extends Tensor & TNumber> Softmax<T> create(Scope scope, Operand<T> logits) {
     OperationBuilder opBuilder = scope.env().opBuilder("Softmax", scope.makeOpName("Softmax"));
     opBuilder.addInput(logits.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 41281b996ff..61a8bb03593 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes softmax cross entropy cost and gradients to backpropagate.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class SoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
+public final class SoftmaxCrossEntropyWithLogits<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SoftmaxCrossEntropyWithLogits operation.
@@ -49,7 +49,7 @@ public final class SoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawO
    * @return a new instance of SoftmaxCrossEntropyWithLogits
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<T> labels) {
+  public static <T extends Tensor & TNumber> SoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<T> labels) {
     OperationBuilder opBuilder = scope.env().opBuilder("SoftmaxCrossEntropyWithLogits", scope.makeOpName("SoftmaxCrossEntropyWithLogits"));
     opBuilder.addInput(features.asOutput());
     opBuilder.addInput(labels.asOutput());
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 e117be94537..c40a7a5fb81 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes softsign: `features / (abs(features) + 1)`.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Softsign<T extends TNumber> extends RawOp implements Operand<T> {
+public final class Softsign<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Softsign operation.
@@ -44,7 +44,7 @@ public final class Softsign<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of Softsign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Softsign<T> create(Scope scope, Operand<T> features) {
+  public static <T extends Tensor & TNumber> Softsign<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Softsign", scope.makeOpName("Softsign"));
     opBuilder.addInput(features.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 2c4fd467661..5ec3babf609 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes softsign gradients for a softsign operation.
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SoftsignGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SoftsignGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SoftsignGrad operation.
@@ -44,7 +44,7 @@ public final class SoftsignGrad<T extends TNumber> extends RawOp implements Oper
    * @return a new instance of SoftsignGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SoftsignGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends Tensor & TNumber> SoftsignGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("SoftsignGrad", scope.makeOpName("SoftsignGrad"));
     opBuilder.addInput(gradients.asOutput());
     opBuilder.addInput(features.asOutput());
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 b8ab8d48658..32fe3d007ac 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * SpaceToBatch for 4-D tensors of type T.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class SpaceToBatch<T extends TType> extends RawOp implements Operand<T> {
+public final class SpaceToBatch<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SpaceToBatch operation.
@@ -122,7 +122,7 @@ public final class SpaceToBatch<T extends TType> extends RawOp implements Operan
    * @return a new instance of SpaceToBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SpaceToBatch<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Long blockSize) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SpaceToBatch<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Long blockSize) {
     OperationBuilder opBuilder = scope.env().opBuilder("SpaceToBatch", scope.makeOpName("SpaceToBatch"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(paddings.asOutput());
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 100ac91e7da..b3c0f27a374 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * SpaceToDepth for tensors of type T.
@@ -107,7 +107,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class SpaceToDepth<T extends TType> extends RawOp implements Operand<T> {
+public final class SpaceToDepth<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.SpaceToDepth}
@@ -138,7 +138,7 @@ private Options() {
    * @return a new instance of SpaceToDepth
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SpaceToDepth<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
+  public static <T extends Tensor> SpaceToDepth<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SpaceToDepth", scope.makeOpName("SpaceToDepth"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 f2434cd4eb8..9ddb57134df 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes softmax cross entropy cost and gradients to backpropagate.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class SparseSoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
+public final class SparseSoftmaxCrossEntropyWithLogits<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSoftmaxCrossEntropyWithLogits operation.
@@ -53,7 +53,7 @@ public final class SparseSoftmaxCrossEntropyWithLogits<T extends TNumber> extend
    * @return a new instance of SparseSoftmaxCrossEntropyWithLogits
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SparseSoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<U> labels) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<U> labels) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSoftmaxCrossEntropyWithLogits", scope.makeOpName("SparseSoftmaxCrossEntropyWithLogits"));
     opBuilder.addInput(features.asOutput());
     opBuilder.addInput(labels.asOutput());
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 28a810ebc54..a14beb011c1 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Finds values and indices of the `k` largest elements for the last dimension.
@@ -46,7 +46,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "nn")
-public final class TopK<T extends TNumber> extends RawOp {
+public final class TopK<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.TopK}
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of TopK
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> TopK<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Options... options) {
+  public static <T extends Tensor & TNumber> TopK<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TopKV2", scope.makeOpName("TopK"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(k.asOutput());
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 f759acb0a51..660da0d22ea 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
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Dequantize the 'input' tensor into a float or bfloat16 Tensor.
@@ -85,7 +85,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Dequantize<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Dequantize<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.Dequantize}
@@ -137,7 +137,7 @@ private Options() {
    * @return a new instance of Dequantize
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Dequantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<U> dtype, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Dequantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dequantize", scope.makeOpName("Dequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(minRange.asOutput());
@@ -171,7 +171,7 @@ public static <U extends TNumber, T extends TType> Dequantize<U> create(Scope sc
    * @return a new instance of Dequantize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Dequantize<TFloat32> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, Options... options) {
+  public static <T extends Tensor> Dequantize<TFloat32> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, Options... options) {
     return create(scope, input, minRange, maxRange, TFloat32.DTYPE, options);
   }
   
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 1b6ed2fd791..0eca716f70c 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Quantize the 'input' tensor of type float to 'output' tensor of type 'T'.
@@ -145,7 +145,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Quantize<T extends TType> extends RawOp {
+public final class Quantize<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.Quantize}
@@ -220,7 +220,7 @@ private Options() {
    * @return a new instance of Quantize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Quantize<T> create(Scope scope, Operand<TFloat32> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<T> T, Options... options) {
+  public static <T extends Tensor> Quantize<T> create(Scope scope, Operand<TFloat32> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<T> T, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizeV2", scope.makeOpName("Quantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(minRange.asOutput());
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 d90d91706d9..5e8d3799c03 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Quantizes then dequantizes a tensor.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizeAndDequantize<T extends TNumber> extends RawOp implements Operand<T> {
+public final class QuantizeAndDequantize<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.QuantizeAndDequantize}
@@ -98,7 +98,7 @@ private Options() {
    * @return a new instance of QuantizeAndDequantize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> QuantizeAndDequantize<T> create(Scope scope, Operand<T> input, Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits, Options... options) {
+  public static <T extends Tensor & TNumber> QuantizeAndDequantize<T> create(Scope scope, Operand<T> input, Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizeAndDequantizeV3", scope.makeOpName("QuantizeAndDequantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputMin.asOutput());
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 3b77c20f70c..4cebed52421 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Convert the quantized 'input' tensor into a lower-precision 'output', using the
@@ -58,7 +58,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizeDownAndShrinkRange<U extends TType> extends RawOp {
+public final class QuantizeDownAndShrinkRange<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizeDownAndShrinkRange operation.
@@ -71,7 +71,7 @@ public final class QuantizeDownAndShrinkRange<U extends TType> extends RawOp {
    * @return a new instance of QuantizeDownAndShrinkRange
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> QuantizeDownAndShrinkRange<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> QuantizeDownAndShrinkRange<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizeDownAndShrinkRange", scope.makeOpName("QuantizeDownAndShrinkRange"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputMin.asOutput());
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 46f73857d91..332f2101bee 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
@@ -21,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -28,7 +29,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates quantized tensors along one dimension.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizedConcat<T extends TType> extends RawOp {
+public final class QuantizedConcat<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedConcat operation.
@@ -51,7 +51,7 @@ public final class QuantizedConcat<T extends TType> extends RawOp {
    * @return a new instance of QuantizedConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> QuantizedConcat<T> create(Scope scope, Operand<TInt32> concatDim, Iterable<Operand<T>> values, Iterable<Operand<TFloat32>> inputMins, Iterable<Operand<TFloat32>> inputMaxes) {
+  public static <T extends Tensor> QuantizedConcat<T> create(Scope scope, Operand<TInt32> concatDim, Iterable<Operand<T>> values, Iterable<Operand<TFloat32>> inputMins, Iterable<Operand<TFloat32>> inputMaxes) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConcat", scope.makeOpName("QuantizedConcat"));
     opBuilder.addInput(concatDim.asOutput());
     opBuilder.addInputList(Operands.asOutputs(values));
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java
index 42da8ab044f..3644fbad609 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java
@@ -22,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndDequantize<W extends TNumber> extends RawOp implements Operand<W> {
+public final class QuantizedMatMulWithBiasAndDequantize<W extends Tensor & TNumber> extends RawOp implements Operand<W> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.QuantizedMatMulWithBiasAndDequantize}
@@ -90,7 +90,7 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndDequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TNumber, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBiasAndDequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
+  public static <W extends Tensor & TNumber, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBiasAndDequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndDequantize", scope.makeOpName("QuantizedMatMulWithBiasAndDequantize"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java
index a3ececf8fb3..a20f936928b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java
@@ -22,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndRequantize<W extends TType> extends RawOp {
+public final class QuantizedMatMulWithBiasAndRequantize<W extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.QuantizedMatMulWithBiasAndRequantize}
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBiasAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
+  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBiasAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndRequantize", scope.makeOpName("QuantizedMatMulWithBiasAndRequantize"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 85eddcd506a..22424b45998 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes a range that covers the actual values present in a quantized tensor.
@@ -49,7 +49,7 @@ public final class RequantizationRange extends RawOp {
    * @return a new instance of RequantizationRange
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RequantizationRange create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
+  public static <T extends Tensor> RequantizationRange create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("RequantizationRange", scope.makeOpName("RequantizationRange"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputMin.asOutput());
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 987dd660095..a7fcd8f68fa 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts the quantized `input` tensor into a lower-precision `output`.
@@ -43,7 +43,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Requantize<U extends TType> extends RawOp {
+public final class Requantize<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Requantize operation.
@@ -58,7 +58,7 @@ public final class Requantize<U extends TType> extends RawOp {
    * @return a new instance of Requantize
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> Requantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
+  public static <U extends Tensor, T extends Tensor> Requantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Requantize", scope.makeOpName("Requantize"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(inputMin.asOutput());
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 c200b82da2a..5187a14f018 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
@@ -23,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Gather ragged slices from `params` axis `0` according to `indices`.
@@ -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 RawOp {
+public final class RaggedGather<T extends Tensor & TNumber, U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedGather operation.
@@ -84,7 +84,7 @@ public final class RaggedGather<T extends TNumber, U extends TType> extends RawO
    * @return a new instance of RaggedGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType, V extends TNumber> RaggedGather<T, U> create(Scope scope, Iterable<Operand<T>> paramsNestedSplits, Operand<U> paramsDenseValues, Operand<V> indices, Long OUTPUTRAGGEDRANK) {
+  public static <T extends Tensor & TNumber, U extends Tensor, V extends Tensor & TNumber> RaggedGather<T, U> create(Scope scope, Iterable<Operand<T>> paramsNestedSplits, Operand<U> paramsDenseValues, Operand<V> indices, Long OUTPUTRAGGEDRANK) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedGather", scope.makeOpName("RaggedGather"));
     opBuilder.addInputList(Operands.asOutputs(paramsNestedSplits));
     opBuilder.addInput(paramsDenseValues.asOutput());
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 8fd3fb45bea..eb384c652e7 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns a `RaggedTensor` containing the specified sequences of numbers.
@@ -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 RawOp {
+public final class RaggedRange<U extends Tensor & TNumber, T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedRange operation.
@@ -64,7 +64,7 @@ public final class RaggedRange<U extends TNumber, T extends TNumber> extends Raw
    * @return a new instance of RaggedRange
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> RaggedRange<U, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas, DataType<U> Tsplits) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RaggedRange<U, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas, DataType<U> Tsplits) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedRange", scope.makeOpName("RaggedRange"));
     opBuilder.addInput(starts.asOutput());
     opBuilder.addInput(limits.asOutput());
@@ -84,7 +84,7 @@ public static <U extends TNumber, T extends TNumber> RaggedRange<U, T> create(Sc
    * @return a new instance of RaggedRange
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> RaggedRange<TInt64, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas) {
+  public static <T extends Tensor & TNumber> RaggedRange<TInt64, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas) {
     return create(scope, starts, limits, deltas, TInt64.DTYPE);
   }
   
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 3b094d70e0b..eb9e9cb0edd 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,13 +24,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Decodes a `variant` Tensor into a `RaggedTensor`.
@@ -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 RawOp {
+public final class RaggedTensorFromVariant<U extends Tensor & TNumber, T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorFromVariant operation.
@@ -67,7 +67,7 @@ public final class RaggedTensorFromVariant<U extends TNumber, T extends TType> e
    * @return a new instance of RaggedTensorFromVariant
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> RaggedTensorFromVariant<U, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues, DataType<U> Tsplits) {
+  public static <U extends Tensor & TNumber, T extends Tensor> RaggedTensorFromVariant<U, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues, DataType<U> Tsplits) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorFromVariant", scope.makeOpName("RaggedTensorFromVariant"));
     opBuilder.addInput(encodedRagged.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -91,7 +91,7 @@ public static <U extends TNumber, T extends TType> RaggedTensorFromVariant<U, T>
    * @return a new instance of RaggedTensorFromVariant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RaggedTensorFromVariant<TInt64, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues) {
+  public static <T extends Tensor> RaggedTensorFromVariant<TInt64, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues) {
     return create(scope, encodedRagged, inputRaggedRank, outputRaggedRank, Tvalues, TInt64.DTYPE);
   }
   
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 d4443b915ac..7021e3204b6 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
@@ -21,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -28,7 +29,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts a `RaggedTensor` into a `SparseTensor` with the same values.
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code sparseValues()} output
  */
-public final class RaggedTensorToSparse<U extends TType> extends RawOp {
+public final class RaggedTensorToSparse<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToSparse operation.
@@ -50,7 +50,7 @@ public final class RaggedTensorToSparse<U extends TType> extends RawOp {
    * @return a new instance of RaggedTensorToSparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> RaggedTensorToSparse<U> create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues) {
+  public static <U extends Tensor, T extends Tensor & TNumber> RaggedTensorToSparse<U> create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorToSparse", scope.makeOpName("RaggedTensorToSparse"));
     opBuilder.addInputList(Operands.asOutputs(rtNestedSplits));
     opBuilder.addInput(rtDenseValues.asOutput());
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 d5b03b37352..04854bca2e3 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
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Create a dense tensor from a ragged tensor, possibly altering its shape.
@@ -58,7 +58,7 @@
  * 
  * @param <U> data type for {@code result()} output
  */
-public final class RaggedTensorToTensor<U extends TType> extends RawOp implements Operand<U> {
+public final class RaggedTensorToTensor<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToTensor operation.
@@ -106,7 +106,7 @@ public final class RaggedTensorToTensor<U extends TType> extends RawOp implement
    * @return a new instance of RaggedTensorToTensor
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber, V extends TNumber> RaggedTensorToTensor<U> create(Scope scope, Operand<T> shape, Operand<U> values, Operand<U> defaultValue, Iterable<Operand<V>> rowPartitionTensors, List<String> rowPartitionTypes) {
+  public static <U extends Tensor, T extends Tensor & TNumber, V extends Tensor & TNumber> RaggedTensorToTensor<U> create(Scope scope, Operand<T> shape, Operand<U> values, Operand<U> defaultValue, Iterable<Operand<V>> rowPartitionTensors, List<String> rowPartitionTypes) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorToTensor", scope.makeOpName("RaggedTensorToTensor"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(values.asOutput());
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 b8c1570a573..b97f50aa371 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Encodes a `RaggedTensor` into a `variant` Tensor.
@@ -45,7 +45,7 @@
  * corresponding decoding logic.
  * 
  */
-public final class RaggedTensorToVariant extends RawOp implements Operand<TType> {
+public final class RaggedTensorToVariant extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToVariant operation.
@@ -58,7 +58,7 @@ public final class RaggedTensorToVariant extends RawOp implements Operand<TType>
    * @return a new instance of RaggedTensorToVariant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> RaggedTensorToVariant create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues, Boolean batchedInput) {
+  public static <T extends Tensor & TNumber, U extends Tensor> RaggedTensorToVariant create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues, Boolean batchedInput) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorToVariant", scope.makeOpName("RaggedTensorToVariant"));
     opBuilder.addInputList(Operands.asOutputs(rtNestedSplits));
     opBuilder.addInput(rtDenseValues.asOutput());
@@ -76,8 +76,8 @@ public Output<?> encodedRagged() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) encodedRagged;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) encodedRagged;
   }
   
   private Output<?> encodedRagged;
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 41fb03d9dc2..9dc925b6a67 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Draws samples from a multinomial distribution.
@@ -37,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class Multinomial<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Multinomial<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.Multinomial}
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of Multinomial
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> Multinomial<U> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, DataType<U> outputDtype, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> Multinomial<U> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, DataType<U> outputDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Multinomial", scope.makeOpName("Multinomial"));
     opBuilder.addInput(logits.asOutput());
     opBuilder.addInput(numSamples.asOutput());
@@ -110,7 +110,7 @@ public static <U extends TNumber, T extends TNumber> Multinomial<U> create(Scope
    * @return a new instance of Multinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Multinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Options... options) {
+  public static <T extends Tensor & TNumber> Multinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Options... options) {
     return create(scope, logits, numSamples, TInt64.DTYPE, options);
   }
   
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 b251813e265..bfb4d78034f 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Non-deterministically generates some integers.
@@ -36,7 +36,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class NonDeterministicInts<U extends TType> extends RawOp implements Operand<U> {
+public final class NonDeterministicInts<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new NonDeterministicInts operation.
@@ -47,7 +47,7 @@ public final class NonDeterministicInts<U extends TType> extends RawOp implement
    * @return a new instance of NonDeterministicInts
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> NonDeterministicInts<U> create(Scope scope, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends Tensor, T extends Tensor> NonDeterministicInts<U> create(Scope scope, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("NonDeterministicInts", scope.makeOpName("NonDeterministicInts"));
     opBuilder.addInput(shape.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -63,7 +63,7 @@ public static <U extends TType, T extends TType> NonDeterministicInts<U> create(
    * @return a new instance of NonDeterministicInts
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> NonDeterministicInts<TInt64> create(Scope scope, Operand<T> shape) {
+  public static <T extends Tensor> NonDeterministicInts<TInt64> create(Scope scope, Operand<T> shape) {
     return create(scope, shape, TInt64.DTYPE);
   }
   
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 8ed64aa14a7..e8bf7f6c2c0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a normal distribution. The parameters may each be a
@@ -37,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class ParameterizedTruncatedNormal<U extends TNumber> extends RawOp implements Operand<U> {
+public final class ParameterizedTruncatedNormal<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.ParameterizedTruncatedNormal}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of ParameterizedTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> ParameterizedTruncatedNormal<U> create(Scope scope, Operand<T> shape, Operand<U> means, Operand<U> stdevs, Operand<U> minvals, Operand<U> maxvals, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> ParameterizedTruncatedNormal<U> create(Scope scope, Operand<T> shape, Operand<U> means, Operand<U> stdevs, Operand<U> minvals, Operand<U> maxvals, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParameterizedTruncatedNormal", scope.makeOpName("ParameterizedTruncatedNormal"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(means.asOutput());
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 65ae0fbcbb4..68e01c497bf 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from the Gamma distribution(s) described by alpha.
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomGamma<U extends TNumber> extends RawOp implements Operand<U> {
+public final class RandomGamma<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomGamma}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of RandomGamma
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> RandomGamma<U> create(Scope scope, Operand<T> shape, Operand<U> alpha, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomGamma<U> create(Scope scope, Operand<T> shape, Operand<U> alpha, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomGamma", scope.makeOpName("RandomGamma"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(alpha.asOutput());
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 ba25e19b24e..da6f9f8d291 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the derivative of a Gamma random sample w.r.t. `alpha`.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RandomGammaGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class RandomGammaGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new RandomGammaGrad operation.
@@ -44,7 +44,7 @@ public final class RandomGammaGrad<T extends TNumber> extends RawOp implements O
    * @return a new instance of RandomGammaGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> RandomGammaGrad<T> create(Scope scope, Operand<T> alpha, Operand<T> sample) {
+  public static <T extends Tensor & TNumber> RandomGammaGrad<T> create(Scope scope, Operand<T> alpha, Operand<T> sample) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomGammaGrad", scope.makeOpName("RandomGammaGrad"));
     opBuilder.addInput(alpha.asOutput());
     opBuilder.addInput(sample.asOutput());
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 e7bcb3d6855..dc788f9cfa3 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from the Poisson distribution(s) described by rate.
@@ -46,7 +46,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomPoisson<V extends TNumber> extends RawOp implements Operand<V> {
+public final class RandomPoisson<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomPoisson}
@@ -91,7 +91,7 @@ private Options() {
    * @return a new instance of RandomPoisson
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> RandomPoisson<V> create(Scope scope, Operand<T> shape, Operand<U> rate, DataType<V> dtype, Options... options) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<V> create(Scope scope, Operand<T> shape, Operand<U> rate, DataType<V> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomPoissonV2", scope.makeOpName("RandomPoisson"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(rate.asOutput());
@@ -122,7 +122,7 @@ public static <V extends TNumber, T extends TNumber, U extends TNumber> RandomPo
    * @return a new instance of RandomPoisson
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> RandomPoisson<TInt64> create(Scope scope, Operand<T> shape, Operand<U> rate, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<TInt64> create(Scope scope, Operand<T> shape, Operand<U> rate, Options... options) {
     return create(scope, shape, rate, TInt64.DTYPE, options);
   }
   
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 738d92b7f0e..c31c6541e7f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Randomly shuffles a tensor along its first dimension.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomShuffle<T extends TType> extends RawOp implements Operand<T> {
+public final class RandomShuffle<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomShuffle}
@@ -84,7 +84,7 @@ private Options() {
    * @return a new instance of RandomShuffle
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RandomShuffle<T> create(Scope scope, Operand<T> value, Options... options) {
+  public static <T extends Tensor> RandomShuffle<T> create(Scope scope, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomShuffle", scope.makeOpName("RandomShuffle"));
     opBuilder.addInput(value.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 48e08f355b3..6ea9e5633e6 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a normal distribution.
@@ -37,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomStandardNormal<U extends TNumber> extends RawOp implements Operand<U> {
+public final class RandomStandardNormal<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomStandardNormal}
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of RandomStandardNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> RandomStandardNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomStandardNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomStandardNormal", scope.makeOpName("RandomStandardNormal"));
     opBuilder.addInput(shape.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 121a58533c1..a920775fb4d 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a uniform distribution.
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomUniform<U extends TNumber> extends RawOp implements Operand<U> {
+public final class RandomUniform<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomUniform}
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of RandomUniform
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> RandomUniform<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniform<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomUniform", scope.makeOpName("RandomUniform"));
     opBuilder.addInput(shape.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 b2eafcadf4b..08f8e4b9143 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random integers from a uniform distribution.
@@ -42,7 +42,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomUniformInt<U extends TNumber> extends RawOp implements Operand<U> {
+public final class RandomUniformInt<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomUniformInt}
@@ -85,7 +85,7 @@ private Options() {
    * @return a new instance of RandomUniformInt
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> RandomUniformInt<U> create(Scope scope, Operand<T> shape, Operand<U> minval, Operand<U> maxval, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniformInt<U> create(Scope scope, Operand<T> shape, Operand<U> minval, Operand<U> maxval, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomUniformInt", scope.makeOpName("RandomUniformInt"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(minval.asOutput());
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 f6b9ed59a68..6514b4ac268 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatefulRandomBinomial<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatefulRandomBinomial<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatefulRandomBinomial operation.
@@ -49,7 +49,7 @@ public final class StatefulRandomBinomial<V extends TNumber> extends RawOp imple
    * @return a new instance of StatefulRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatefulRandomBinomial<V> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs, DataType<V> dtype) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<V> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulRandomBinomial", scope.makeOpName("StatefulRandomBinomial"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(algorithm.asOutput());
@@ -73,7 +73,7 @@ public static <V extends TNumber, T extends TNumber, U extends TNumber> Stateful
    * @return a new instance of StatefulRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> StatefulRandomBinomial<TInt64> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<TInt64> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs) {
     return create(scope, resource, algorithm, shape, counts, probs, TInt64.DTYPE);
   }
   
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 fd0f1cd16a4..e8f769af15d 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a normal distribution.
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatefulStandardNormal<U extends TType> extends RawOp implements Operand<U> {
+public final class StatefulStandardNormal<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulStandardNormal operation.
@@ -51,7 +51,7 @@ public final class StatefulStandardNormal<U extends TType> extends RawOp impleme
    * @return a new instance of StatefulStandardNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> StatefulStandardNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends Tensor, T extends Tensor> StatefulStandardNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulStandardNormalV2", scope.makeOpName("StatefulStandardNormal"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(algorithm.asOutput());
@@ -71,7 +71,7 @@ public static <U extends TType, T extends TType> StatefulStandardNormal<U> creat
    * @return a new instance of StatefulStandardNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> StatefulStandardNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
+  public static <T extends Tensor> StatefulStandardNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return create(scope, resource, algorithm, shape, TFloat32.DTYPE);
   }
   
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 97ad2eb4f00..99324e10c84 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a truncated normal distribution.
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulTruncatedNormal<U extends TType> extends RawOp implements Operand<U> {
+public final class StatefulTruncatedNormal<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulTruncatedNormal operation.
@@ -52,7 +52,7 @@ public final class StatefulTruncatedNormal<U extends TType> extends RawOp implem
    * @return a new instance of StatefulTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> StatefulTruncatedNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends Tensor, T extends Tensor> StatefulTruncatedNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulTruncatedNormal", scope.makeOpName("StatefulTruncatedNormal"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(algorithm.asOutput());
@@ -72,7 +72,7 @@ public static <U extends TType, T extends TType> StatefulTruncatedNormal<U> crea
    * @return a new instance of StatefulTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> StatefulTruncatedNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
+  public static <T extends Tensor> StatefulTruncatedNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return create(scope, resource, algorithm, shape, TFloat32.DTYPE);
   }
   
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 8c6d86dd507..67f68909be6 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a uniform distribution.
@@ -38,7 +38,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniform<U extends TType> extends RawOp implements Operand<U> {
+public final class StatefulUniform<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulUniform operation.
@@ -51,7 +51,7 @@ public final class StatefulUniform<U extends TType> extends RawOp implements Ope
    * @return a new instance of StatefulUniform
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> StatefulUniform<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends Tensor, T extends Tensor> StatefulUniform<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulUniform", scope.makeOpName("StatefulUniform"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(algorithm.asOutput());
@@ -71,7 +71,7 @@ public static <U extends TType, T extends TType> StatefulUniform<U> create(Scope
    * @return a new instance of StatefulUniform
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> StatefulUniform<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
+  public static <T extends Tensor> StatefulUniform<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return create(scope, resource, algorithm, shape, TFloat32.DTYPE);
   }
   
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 e234af42486..6f6cae38905 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random integers from a uniform distribution.
@@ -36,7 +36,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniformFullInt<U extends TType> extends RawOp implements Operand<U> {
+public final class StatefulUniformFullInt<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulUniformFullInt operation.
@@ -49,7 +49,7 @@ public final class StatefulUniformFullInt<U extends TType> extends RawOp impleme
    * @return a new instance of StatefulUniformFullInt
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> StatefulUniformFullInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends Tensor, T extends Tensor> StatefulUniformFullInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulUniformFullInt", scope.makeOpName("StatefulUniformFullInt"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(algorithm.asOutput());
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 a5550877593..11026bf281a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random integers from a uniform distribution.
@@ -41,7 +41,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniformInt<U extends TType> extends RawOp implements Operand<U> {
+public final class StatefulUniformInt<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new StatefulUniformInt operation.
@@ -55,7 +55,7 @@ public final class StatefulUniformInt<U extends TType> extends RawOp implements
    * @return a new instance of StatefulUniformInt
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> StatefulUniformInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> minval, Operand<U> maxval) {
+  public static <U extends Tensor, T extends Tensor> StatefulUniformInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> minval, Operand<U> maxval) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulUniformInt", scope.makeOpName("StatefulUniformInt"));
     opBuilder.addInput(resource.asOutput());
     opBuilder.addInput(algorithm.asOutput());
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 d5473395eb3..86b2956deac 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Draws samples from a multinomial distribution.
@@ -37,7 +37,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessMultinomial<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatelessMultinomial<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessMultinomial operation.
@@ -51,7 +51,7 @@ public final class StatelessMultinomial<V extends TNumber> extends RawOp impleme
    * @return a new instance of StatelessMultinomial
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessMultinomial<V> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed, DataType<V> outputDtype) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<V> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed, DataType<V> outputDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessMultinomial", scope.makeOpName("StatelessMultinomial"));
     opBuilder.addInput(logits.asOutput());
     opBuilder.addInput(numSamples.asOutput());
@@ -72,7 +72,7 @@ public static <V extends TNumber, T extends TNumber, U extends TNumber> Stateles
    * @return a new instance of StatelessMultinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> StatelessMultinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed) {
     return create(scope, logits, numSamples, seed, TInt64.DTYPE);
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java
index 9629ee7620e..7101fd58126 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom random numbers from a binomial distribution.
@@ -39,7 +39,7 @@
  * 
  * @param <W> data type for {@code output()} output
  */
-public final class StatelessRandomBinomial<W extends TNumber> extends RawOp implements Operand<W> {
+public final class StatelessRandomBinomial<W extends Tensor & TNumber> extends RawOp implements Operand<W> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomBinomial operation.
@@ -55,7 +55,7 @@ public final class StatelessRandomBinomial<W extends TNumber> extends RawOp impl
    * @return a new instance of StatelessRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TNumber, T extends TNumber, U extends TNumber, V extends TNumber> StatelessRandomBinomial<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs, DataType<W> dtype) {
+  public static <W extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> StatelessRandomBinomial<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs, DataType<W> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomBinomial", scope.makeOpName("StatelessRandomBinomial"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
@@ -79,7 +79,7 @@ public static <W extends TNumber, T extends TNumber, U extends TNumber, V extend
    * @return a new instance of StatelessRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> StatelessRandomBinomial<TInt64> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> StatelessRandomBinomial<TInt64> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs) {
     return create(scope, shape, seed, counts, probs, TInt64.DTYPE);
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java
index 815e4b8c1ad..e4668fe6503 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom random numbers from a gamma distribution.
@@ -37,7 +37,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class StatelessRandomGamma<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatelessRandomGamma<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomGamma operation.
@@ -50,7 +50,7 @@ public final class StatelessRandomGamma<V extends TNumber> extends RawOp impleme
    * @return a new instance of StatelessRandomGamma
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomGamma<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> alpha) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomGamma<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> alpha) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomGammaV2", scope.makeOpName("StatelessRandomGamma"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
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 028537a3417..02c0aa5ea69 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom values from a normal distribution.
@@ -40,7 +40,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessRandomNormal<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatelessRandomNormal<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomNormal operation.
@@ -52,7 +52,7 @@ public final class StatelessRandomNormal<V extends TNumber> extends RawOp implem
    * @return a new instance of StatelessRandomNormal
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomNormal", scope.makeOpName("StatelessRandomNormal"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
@@ -70,7 +70,7 @@ public static <V extends TNumber, T extends TNumber, U extends TNumber> Stateles
    * @return a new instance of StatelessRandomNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> StatelessRandomNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
     return create(scope, shape, seed, TFloat32.DTYPE);
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java
index e0c7e949dd3..6908af2d5df 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java
@@ -22,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom random numbers from a Poisson distribution.
@@ -38,7 +38,7 @@
  * 
  * @param <W> data type for {@code output()} output
  */
-public final class StatelessRandomPoisson<W extends TNumber> extends RawOp implements Operand<W> {
+public final class StatelessRandomPoisson<W extends Tensor & TNumber> extends RawOp implements Operand<W> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomPoisson operation.
@@ -52,7 +52,7 @@ public final class StatelessRandomPoisson<W extends TNumber> extends RawOp imple
    * @return a new instance of StatelessRandomPoisson
    */
   @Endpoint(describeByClass = true)
-  public static <W extends TNumber, T extends TNumber, U extends TNumber, V extends TNumber> StatelessRandomPoisson<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> lam, DataType<W> dtype) {
+  public static <W extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> StatelessRandomPoisson<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> lam, DataType<W> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomPoisson", scope.makeOpName("StatelessRandomPoisson"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
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 5ea49ccf36d..ac7e814a03f 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom random values from a uniform distribution.
@@ -41,7 +41,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessRandomUniform<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatelessRandomUniform<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomUniform operation.
@@ -53,7 +53,7 @@ public final class StatelessRandomUniform<V extends TNumber> extends RawOp imple
    * @return a new instance of StatelessRandomUniform
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniform<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomUniform", scope.makeOpName("StatelessRandomUniform"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
@@ -71,7 +71,7 @@ public static <V extends TNumber, T extends TNumber, U extends TNumber> Stateles
    * @return a new instance of StatelessRandomUniform
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> StatelessRandomUniform<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
     return create(scope, shape, seed, TFloat32.DTYPE);
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java
index 657153d3098..20d68c68b8a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java
@@ -22,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom random integers from a uniform distribution.
@@ -38,7 +38,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class StatelessRandomUniformFullInt<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatelessRandomUniformFullInt<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomUniformFullInt operation.
@@ -50,7 +50,7 @@ public final class StatelessRandomUniformFullInt<V extends TNumber> extends RawO
    * @return a new instance of StatelessRandomUniformFullInt
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniformFullInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniformFullInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomUniformFullInt", scope.makeOpName("StatelessRandomUniformFullInt"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
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 ebb569ea222..302364dcda1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom random integers from a uniform distribution.
@@ -37,7 +37,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class StatelessRandomUniformInt<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatelessRandomUniformInt<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomUniformInt operation.
@@ -50,7 +50,7 @@ public final class StatelessRandomUniformInt<V extends TNumber> extends RawOp im
    * @return a new instance of StatelessRandomUniformInt
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniformInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> minval, Operand<V> maxval) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniformInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> minval, Operand<V> maxval) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomUniformInt", scope.makeOpName("StatelessRandomUniformInt"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
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 180e5ffa4b5..4e411a0e918 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs deterministic pseudorandom values from a truncated normal distribution.
@@ -42,7 +42,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessTruncatedNormal<V extends TNumber> extends RawOp implements Operand<V> {
+public final class StatelessTruncatedNormal<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessTruncatedNormal operation.
@@ -54,7 +54,7 @@ public final class StatelessTruncatedNormal<V extends TNumber> extends RawOp imp
    * @return a new instance of StatelessTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessTruncatedNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessTruncatedNormal", scope.makeOpName("StatelessTruncatedNormal"));
     opBuilder.addInput(shape.asOutput());
     opBuilder.addInput(seed.asOutput());
@@ -72,7 +72,7 @@ public static <V extends TNumber, T extends TNumber, U extends TNumber> Stateles
    * @return a new instance of StatelessTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> StatelessTruncatedNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
     return create(scope, shape, seed, TFloat32.DTYPE);
   }
   
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 b40ddfb6e47..e18fe049a44 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a truncated normal distribution.
@@ -39,7 +39,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class TruncatedNormal<U extends TNumber> extends RawOp implements Operand<U> {
+public final class TruncatedNormal<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.TruncatedNormal}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of TruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TNumber> TruncatedNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
+  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> TruncatedNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TruncatedNormal", scope.makeOpName("TruncatedNormal"));
     opBuilder.addInput(shape.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 029a9990900..2a02cb822ff 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft extends RawOp implements Operand<TType> {
+public final class BatchFft extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft operation.
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 c8357878666..c3c7f41d95c 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft2d extends RawOp implements Operand<TType> {
+public final class BatchFft2d extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft2d operation.
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 4ad58e855ae..2b410eb46c6 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft3d extends RawOp implements Operand<TType> {
+public final class BatchFft3d extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft3d operation.
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 0e098f94b72..dc39ac5eb87 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft extends RawOp implements Operand<TType> {
+public final class BatchIfft extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft operation.
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 e689c9061d4..b65861e69f5 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft2d extends RawOp implements Operand<TType> {
+public final class BatchIfft2d extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft2d operation.
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 5f23ed1ca7a..37273cc46d1 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft3d extends RawOp implements Operand<TType> {
+public final class BatchIfft3d extends RawOp implements Operand<Tensor> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft3d operation.
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 802788288a6..c1f55022c88 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft<T extends TType> extends RawOp implements Operand<T> {
+public final class Fft<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Fft operation.
@@ -46,7 +46,7 @@ public final class Fft<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Fft
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Fft<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Fft<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("FFT", scope.makeOpName("Fft"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 aaafdb8392f..e068214f761 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * 2D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft2d<T extends TType> extends RawOp implements Operand<T> {
+public final class Fft2d<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Fft2d operation.
@@ -46,7 +46,7 @@ public final class Fft2d<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Fft2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Fft2d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Fft2d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("FFT2D", scope.makeOpName("Fft2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 a7b29547d0c..94acb912f81 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * 3D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft3d<T extends TType> extends RawOp implements Operand<T> {
+public final class Fft3d<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Fft3d operation.
@@ -46,7 +46,7 @@ public final class Fft3d<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Fft3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Fft3d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Fft3d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("FFT3D", scope.makeOpName("Fft3d"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 6ba09167aa0..8e2d5d51da7 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Inverse fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft<T extends TType> extends RawOp implements Operand<T> {
+public final class Ifft<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ifft operation.
@@ -46,7 +46,7 @@ public final class Ifft<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Ifft
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Ifft<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Ifft<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("IFFT", scope.makeOpName("Ifft"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 086dd9d2338..b2337eee6d4 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 2D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft2d<T extends TType> extends RawOp implements Operand<T> {
+public final class Ifft2d<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ifft2d operation.
@@ -46,7 +46,7 @@ public final class Ifft2d<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Ifft2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Ifft2d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Ifft2d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("IFFT2D", scope.makeOpName("Ifft2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 d1d114fc2d5..6cb44533fe5 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 3D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft3d<T extends TType> extends RawOp implements Operand<T> {
+public final class Ifft3d<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Ifft3d operation.
@@ -46,7 +46,7 @@ public final class Ifft3d<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Ifft3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Ifft3d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Ifft3d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("IFFT3D", scope.makeOpName("Ifft3d"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 8cbeb80aec5..f0b2000b323 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Inverse real-valued fast Fourier transform.
@@ -51,7 +51,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Irfft<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Irfft operation.
@@ -63,7 +63,7 @@ public final class Irfft<U extends TNumber> extends RawOp implements Operand<U>
    * @return a new instance of Irfft
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Irfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Irfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
     OperationBuilder opBuilder = scope.env().opBuilder("IRFFT", scope.makeOpName("Irfft"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(fftLength.asOutput());
@@ -81,7 +81,7 @@ public static <U extends TNumber, T extends TType> Irfft<U> create(Scope scope,
    * @return a new instance of Irfft
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Irfft<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
+  public static <T extends Tensor> Irfft<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
     return create(scope, input, fftLength, TFloat32.DTYPE);
   }
   
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 a383b340c45..47adf7d8d44 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 2D real-valued fast Fourier transform.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft2d<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Irfft2d<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Irfft2d operation.
@@ -64,7 +64,7 @@ public final class Irfft2d<U extends TNumber> extends RawOp implements Operand<U
    * @return a new instance of Irfft2d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Irfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Irfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
     OperationBuilder opBuilder = scope.env().opBuilder("IRFFT2D", scope.makeOpName("Irfft2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(fftLength.asOutput());
@@ -82,7 +82,7 @@ public static <U extends TNumber, T extends TType> Irfft2d<U> create(Scope scope
    * @return a new instance of Irfft2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Irfft2d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
+  public static <T extends Tensor> Irfft2d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
     return create(scope, input, fftLength, TFloat32.DTYPE);
   }
   
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 278bf3eac13..bc8a1ded733 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 3D real-valued fast Fourier transform.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft3d<U extends TNumber> extends RawOp implements Operand<U> {
+public final class Irfft3d<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Irfft3d operation.
@@ -64,7 +64,7 @@ public final class Irfft3d<U extends TNumber> extends RawOp implements Operand<U
    * @return a new instance of Irfft3d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TNumber, T extends TType> Irfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
+  public static <U extends Tensor & TNumber, T extends Tensor> Irfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
     OperationBuilder opBuilder = scope.env().opBuilder("IRFFT3D", scope.makeOpName("Irfft3d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(fftLength.asOutput());
@@ -82,7 +82,7 @@ public static <U extends TNumber, T extends TType> Irfft3d<U> create(Scope scope
    * @return a new instance of Irfft3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Irfft3d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
+  public static <T extends Tensor> Irfft3d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
     return create(scope, input, fftLength, TFloat32.DTYPE);
   }
   
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 5b3dc8a4199..345d72c0180 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Real-valued fast Fourier transform.
@@ -47,7 +47,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft<U extends TType> extends RawOp implements Operand<U> {
+public final class Rfft<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Rfft operation.
@@ -59,7 +59,7 @@ public final class Rfft<U extends TType> extends RawOp implements Operand<U> {
    * @return a new instance of Rfft
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> Rfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
+  public static <U extends Tensor, T extends Tensor & TNumber> Rfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     OperationBuilder opBuilder = scope.env().opBuilder("RFFT", scope.makeOpName("Rfft"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(fftLength.asOutput());
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 7f47b98f969..d614088de46 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * 2D real-valued fast Fourier transform.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft2d<U extends TType> extends RawOp implements Operand<U> {
+public final class Rfft2d<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Rfft2d operation.
@@ -60,7 +60,7 @@ public final class Rfft2d<U extends TType> extends RawOp implements Operand<U> {
    * @return a new instance of Rfft2d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> Rfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
+  public static <U extends Tensor, T extends Tensor & TNumber> Rfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     OperationBuilder opBuilder = scope.env().opBuilder("RFFT2D", scope.makeOpName("Rfft2d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(fftLength.asOutput());
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 7fa5f8f23b7..3bf003c64c3 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * 3D real-valued fast Fourier transform.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft3d<U extends TType> extends RawOp implements Operand<U> {
+public final class Rfft3d<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new Rfft3d operation.
@@ -60,7 +60,7 @@ public final class Rfft3d<U extends TType> extends RawOp implements Operand<U> {
    * @return a new instance of Rfft3d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> Rfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
+  public static <U extends Tensor, T extends Tensor & TNumber> Rfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     OperationBuilder opBuilder = scope.env().opBuilder("RFFT3D", scope.makeOpName("Rfft3d"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(fftLength.asOutput());
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 f3b4e77d1f3..8e9d9e28eda 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles.
@@ -98,7 +98,7 @@ private Options() {
    * @return a new instance of AddManySparseToTensorsMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AddManySparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
+  public static <T extends Tensor> AddManySparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AddManySparseToTensorsMap", scope.makeOpName("AddManySparseToTensorsMap"));
     opBuilder.addInput(sparseIndices.asOutput());
     opBuilder.addInput(sparseValues.asOutput());
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 0cc79427ce1..edfdd9def6e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Add a `SparseTensor` to a `SparseTensorsMap` return its handle.
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of AddSparseToTensorsMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AddSparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
+  public static <T extends Tensor> AddSparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AddSparseToTensorsMap", scope.makeOpName("AddSparseToTensorsMap"));
     opBuilder.addInput(sparseIndices.asOutput());
     opBuilder.addInput(sparseValues.asOutput());
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 7308a8a8ecb..2fdb4a05901 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies set operation along last dimension of 2 `Tensor` inputs.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class DenseToDenseSetOperation<T extends TType> extends RawOp {
+public final class DenseToDenseSetOperation<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.DenseToDenseSetOperation}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of DenseToDenseSetOperation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DenseToDenseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<T> set2, String setOperation, Options... options) {
+  public static <T extends Tensor> DenseToDenseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<T> set2, String setOperation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DenseToDenseSetOperation", scope.makeOpName("DenseToDenseSetOperation"));
     opBuilder.addInput(set1.asOutput());
     opBuilder.addInput(set2.asOutput());
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 85a490c25a0..65a2d153214 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies set operation along last dimension of `Tensor` and `SparseTensor`.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class DenseToSparseSetOperation<T extends TType> extends RawOp {
+public final class DenseToSparseSetOperation<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.DenseToSparseSetOperation}
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of DenseToSparseSetOperation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> DenseToSparseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
+  public static <T extends Tensor> DenseToSparseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DenseToSparseSetOperation", scope.makeOpName("DenseToSparseSetOperation"));
     opBuilder.addInput(set1.asOutput());
     opBuilder.addInput(set2Indices.asOutput());
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 a4fb2ee2e39..ec19524753b 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Deserialize `SparseTensor` objects.
@@ -77,7 +77,7 @@
  * @param <U> data type for {@code sparseValues()} output
  */
 @Operator(group = "sparse")
-public final class DeserializeSparse<U extends TType> extends RawOp {
+public final class DeserializeSparse<U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeserializeSparse operation.
@@ -89,7 +89,7 @@ public final class DeserializeSparse<U extends TType> extends RawOp {
    * @return a new instance of DeserializeSparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TType> DeserializeSparse<U> create(Scope scope, Operand<T> serializedSparse, DataType<U> dtype) {
+  public static <U extends Tensor, T extends Tensor> DeserializeSparse<U> create(Scope scope, Operand<T> serializedSparse, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeserializeSparse", scope.makeOpName("DeserializeSparse"));
     opBuilder.addInput(serializedSparse.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 15751d4ca97..e85002cd92d 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies a sparse gradient to a given accumulator.
@@ -54,7 +54,7 @@ public final class SparseAccumulatorApplyGradient extends RawOp {
    * @return a new instance of SparseAccumulatorApplyGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseAccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<TInt64> gradientIndices, Operand<T> gradientValues, Operand<TInt64> gradientShape, Boolean hasKnownShape) {
+  public static <T extends Tensor> SparseAccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<TInt64> gradientIndices, Operand<T> gradientValues, Operand<TInt64> gradientShape, Boolean hasKnownShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAccumulatorApplyGradient", scope.makeOpName("SparseAccumulatorApplyGradient"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(localStep.asOutput());
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 d072e331bbf..0d360cd8647 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Extracts the average sparse gradient in a SparseConditionalAccumulator.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "sparse")
-public final class SparseAccumulatorTakeGradient<T extends TType> extends RawOp {
+public final class SparseAccumulatorTakeGradient<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAccumulatorTakeGradient operation.
@@ -57,7 +57,7 @@ public final class SparseAccumulatorTakeGradient<T extends TType> extends RawOp
    * @return a new instance of SparseAccumulatorTakeGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseAccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
+  public static <T extends Tensor> SparseAccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAccumulatorTakeGradient", scope.makeOpName("SparseAccumulatorTakeGradient"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(numRequired.asOutput());
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 1bab6a714a0..2f9db91cf41 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds two `SparseTensor` objects to produce another `SparseTensor`.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code sumValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseAdd<T extends TType> extends RawOp {
+public final class SparseAdd<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAdd operation.
@@ -66,7 +66,7 @@ public final class SparseAdd<T extends TType> extends RawOp {
    * @return a new instance of SparseAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseAdd<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape, Operand<U> thresh) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseAdd<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape, Operand<U> thresh) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAdd", scope.makeOpName("SparseAdd"));
     opBuilder.addInput(aIndices.asOutput());
     opBuilder.addInput(aValues.asOutput());
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 1709c008119..3e6aa064a19 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * The gradient operator for the SparseAdd op.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code aValGrad()} output
  */
 @Operator(group = "sparse")
-public final class SparseAddGrad<T extends TType> extends RawOp {
+public final class SparseAddGrad<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAddGrad operation.
@@ -54,7 +54,7 @@ public final class SparseAddGrad<T extends TType> extends RawOp {
    * @return a new instance of SparseAddGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseAddGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> aIndices, Operand<TInt64> bIndices, Operand<TInt64> sumIndices) {
+  public static <T extends Tensor> SparseAddGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> aIndices, Operand<TInt64> bIndices, Operand<TInt64> sumIndices) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAddGrad", scope.makeOpName("SparseAddGrad"));
     opBuilder.addInput(backpropValGrad.asOutput());
     opBuilder.addInput(aIndices.asOutput());
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 1ee35437c40..637eef24ca2 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates a list of `SparseTensor` along the specified dimension.
@@ -77,7 +77,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseConcat<T extends TType> extends RawOp {
+public final class SparseConcat<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseConcat operation.
@@ -91,7 +91,7 @@ public final class SparseConcat<T extends TType> extends RawOp {
    * @return a new instance of SparseConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseConcat<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<T>> values, Iterable<Operand<TInt64>> shapes, Long concatDim) {
+  public static <T extends Tensor> SparseConcat<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<T>> values, Iterable<Operand<TInt64>> shapes, Long concatDim) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseConcat", scope.makeOpName("SparseConcat"));
     opBuilder.addInputList(Operands.asOutputs(indices));
     opBuilder.addInputList(Operands.asOutputs(values));
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 7c9eea707df..be9396e9d21 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * A conditional accumulator for aggregating sparse gradients.
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of SparseConditionalAccumulator
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends Tensor> SparseConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseConditionalAccumulator", scope.makeOpName("SparseConditionalAccumulator"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
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 72d7107e2d5..dfc030fc809 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
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Generates sparse cross from a list of sparse and dense tensors.
@@ -73,7 +73,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseCross<T extends TType> extends RawOp {
+public final class SparseCross<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseCross operation.
@@ -94,7 +94,7 @@ public final class SparseCross<T extends TType> extends RawOp {
    * @return a new instance of SparseCross
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TType> SparseCross<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<?>> values, Iterable<Operand<TInt64>> shapes, Iterable<Operand<?>> denseInputs, Boolean hashedOutput, Long numBuckets, Long hashKey, DataType<T> outType, DataType<U> internalType) {
+  public static <T extends Tensor, U extends Tensor> SparseCross<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<?>> values, Iterable<Operand<TInt64>> shapes, Iterable<Operand<?>> denseInputs, Boolean hashedOutput, Long numBuckets, Long hashKey, DataType<T> outType, DataType<U> internalType) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseCross", scope.makeOpName("SparseCross"));
     opBuilder.addInputList(Operands.asOutputs(indices));
     opBuilder.addInputList(Operands.asOutputs(values));
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 aace49ffa77..a6667f7ee45 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds up a SparseTensor and a dense Tensor, using these special rules:
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseAdd<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseDenseCwiseAdd<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseDenseCwiseAdd operation.
@@ -57,7 +57,7 @@ public final class SparseDenseCwiseAdd<T extends TType> extends RawOp implements
    * @return a new instance of SparseDenseCwiseAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseDenseCwiseAdd<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
+  public static <T extends Tensor> SparseDenseCwiseAdd<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseDenseCwiseAdd", scope.makeOpName("SparseDenseCwiseAdd"));
     opBuilder.addInput(spIndices.asOutput());
     opBuilder.addInput(spValues.asOutput());
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 78e4bcfe8b4..07ee23bbea3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Component-wise divides a SparseTensor by a dense Tensor.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseDiv<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseDenseCwiseDiv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseDenseCwiseDiv operation.
@@ -51,7 +51,7 @@ public final class SparseDenseCwiseDiv<T extends TType> extends RawOp implements
    * @return a new instance of SparseDenseCwiseDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseDenseCwiseDiv<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
+  public static <T extends Tensor> SparseDenseCwiseDiv<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseDenseCwiseDiv", scope.makeOpName("SparseDenseCwiseDiv"));
     opBuilder.addInput(spIndices.asOutput());
     opBuilder.addInput(spValues.asOutput());
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 78b37a2306a..57629eb2dec 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Component-wise multiplies a SparseTensor by a dense Tensor.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseMul<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseDenseCwiseMul<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseDenseCwiseMul operation.
@@ -55,7 +55,7 @@ public final class SparseDenseCwiseMul<T extends TType> extends RawOp implements
    * @return a new instance of SparseDenseCwiseMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseDenseCwiseMul<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
+  public static <T extends Tensor> SparseDenseCwiseMul<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseDenseCwiseMul", scope.makeOpName("SparseDenseCwiseMul"));
     opBuilder.addInput(spIndices.asOutput());
     opBuilder.addInput(spValues.asOutput());
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 47baf154e30..df6f01f7342 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Fills empty rows in the input 2-D `SparseTensor` with a default value.
@@ -72,7 +72,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseFillEmptyRows<T extends TType> extends RawOp {
+public final class SparseFillEmptyRows<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseFillEmptyRows operation.
@@ -87,7 +87,7 @@ public final class SparseFillEmptyRows<T extends TType> extends RawOp {
    * @return a new instance of SparseFillEmptyRows
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseFillEmptyRows<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape, Operand<T> defaultValue) {
+  public static <T extends Tensor> SparseFillEmptyRows<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape, Operand<T> defaultValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseFillEmptyRows", scope.makeOpName("SparseFillEmptyRows"));
     opBuilder.addInput(indices.asOutput());
     opBuilder.addInput(values.asOutput());
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 7289cfa1eef..5b13cc91f8b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * The gradient of SparseFillEmptyRows.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code dValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseFillEmptyRowsGrad<T extends TType> extends RawOp {
+public final class SparseFillEmptyRowsGrad<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseFillEmptyRowsGrad operation.
@@ -54,7 +54,7 @@ public final class SparseFillEmptyRowsGrad<T extends TType> extends RawOp {
    * @return a new instance of SparseFillEmptyRowsGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseFillEmptyRowsGrad<T> create(Scope scope, Operand<TInt64> reverseIndexMap, Operand<T> gradValues) {
+  public static <T extends Tensor> SparseFillEmptyRowsGrad<T> create(Scope scope, Operand<TInt64> reverseIndexMap, Operand<T> gradValues) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseFillEmptyRowsGrad", scope.makeOpName("SparseFillEmptyRowsGrad"));
     opBuilder.addInput(reverseIndexMap.asOutput());
     opBuilder.addInput(gradValues.asOutput());
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 42922e892cd..8f53c65cd61 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Multiply matrix "a" by matrix "b".
@@ -101,7 +101,7 @@ private Options() {
    * @return a new instance of SparseMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SparseMatMul create(Scope scope, Operand<T> a, Operand<U> b, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseMatMul create(Scope scope, Operand<T> a, Operand<U> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatMul", scope.makeOpName("SparseMatMul"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
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 9e8ffaf3484..8ff995ea48c 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the max of elements across dimensions of a SparseTensor.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceMax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseReduceMax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceMax}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of SparseReduceMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SparseReduceMax<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends Tensor & TNumber> SparseReduceMax<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceMax", scope.makeOpName("SparseReduceMax"));
     opBuilder.addInput(inputIndices.asOutput());
     opBuilder.addInput(inputValues.asOutput());
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 de96c4d2105..0cb779ae607 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the max of elements across dimensions of a SparseTensor.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceMaxSparse<T extends TNumber> extends RawOp {
+public final class SparseReduceMaxSparse<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceMaxSparse}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of SparseReduceMaxSparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SparseReduceMaxSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends Tensor & TNumber> SparseReduceMaxSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceMaxSparse", scope.makeOpName("SparseReduceMaxSparse"));
     opBuilder.addInput(inputIndices.asOutput());
     opBuilder.addInput(inputValues.asOutput());
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 b072fb46bfd..32a0a40b660 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a SparseTensor.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceSum<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseReduceSum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceSum}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of SparseReduceSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseReduceSum<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends Tensor> SparseReduceSum<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceSum", scope.makeOpName("SparseReduceSum"));
     opBuilder.addInput(inputIndices.asOutput());
     opBuilder.addInput(inputValues.asOutput());
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 befdc901b28..23abdb81343 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a SparseTensor.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceSumSparse<T extends TType> extends RawOp {
+public final class SparseReduceSumSparse<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceSumSparse}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of SparseReduceSumSparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseReduceSumSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends Tensor> SparseReduceSumSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceSumSparse", scope.makeOpName("SparseReduceSumSparse"));
     opBuilder.addInput(inputIndices.asOutput());
     opBuilder.addInput(inputValues.asOutput());
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 88be4106deb..6199fde8aa2 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Reorders a SparseTensor into the canonical, row-major ordering.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReorder<T extends TType> extends RawOp {
+public final class SparseReorder<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseReorder operation.
@@ -56,7 +56,7 @@ public final class SparseReorder<T extends TType> extends RawOp {
    * @return a new instance of SparseReorder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseReorder<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape) {
+  public static <T extends Tensor> SparseReorder<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReorder", scope.makeOpName("SparseReorder"));
     opBuilder.addInput(inputIndices.asOutput());
     opBuilder.addInput(inputValues.asOutput());
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 785b1149b0a..276076198c0 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the mean along sparse segments of a tensor.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMean<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentMean<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentMean operation.
@@ -52,7 +52,7 @@ public final class SparseSegmentMean<T extends TNumber> extends RawOp implements
    * @return a new instance of SparseSegmentMean
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SparseSegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentMean", scope.makeOpName("SparseSegmentMean"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(indices.asOutput());
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 a0c8e8b8e43..5abe339711b 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients for SparseSegmentMean.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMeanGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentMeanGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentMeanGrad operation.
@@ -51,7 +51,7 @@ public final class SparseSegmentMeanGrad<T extends TNumber> extends RawOp implem
    * @return a new instance of SparseSegmentMeanGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SparseSegmentMeanGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMeanGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentMeanGrad", scope.makeOpName("SparseSegmentMeanGrad"));
     opBuilder.addInput(grad.asOutput());
     opBuilder.addInput(indices.asOutput());
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 0458eca8621..2e32109e991 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the mean along sparse segments of a tensor.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMeanWithNumSegments<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentMeanWithNumSegments<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentMeanWithNumSegments operation.
@@ -55,7 +55,7 @@ public final class SparseSegmentMeanWithNumSegments<T extends TNumber> extends R
    * @return a new instance of SparseSegmentMeanWithNumSegments
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentMeanWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentMeanWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentMeanWithNumSegments", scope.makeOpName("SparseSegmentMeanWithNumSegments"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(indices.asOutput());
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 03b6e015a80..ce500c7a976 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along sparse segments of a tensor divided by the sqrt of N.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtN<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentSqrtN<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSqrtN operation.
@@ -52,7 +52,7 @@ public final class SparseSegmentSqrtN<T extends TNumber> extends RawOp implement
    * @return a new instance of SparseSegmentSqrtN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SparseSegmentSqrtN<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtN<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSqrtN", scope.makeOpName("SparseSegmentSqrtN"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(indices.asOutput());
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 cbe39991793..706e8cd9d15 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes gradients for SparseSegmentSqrtN.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtNGrad<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentSqrtNGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSqrtNGrad operation.
@@ -51,7 +51,7 @@ public final class SparseSegmentSqrtNGrad<T extends TNumber> extends RawOp imple
    * @return a new instance of SparseSegmentSqrtNGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SparseSegmentSqrtNGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtNGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSqrtNGrad", scope.makeOpName("SparseSegmentSqrtNGrad"));
     opBuilder.addInput(grad.asOutput());
     opBuilder.addInput(indices.asOutput());
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 ce787acb499..0d6d1081a7d 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along sparse segments of a tensor divided by the sqrt of N.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtNWithNumSegments<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentSqrtNWithNumSegments<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSqrtNWithNumSegments operation.
@@ -57,7 +57,7 @@ public final class SparseSegmentSqrtNWithNumSegments<T extends TNumber> extends
    * @return a new instance of SparseSegmentSqrtNWithNumSegments
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSqrtNWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSqrtNWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSqrtNWithNumSegments", scope.makeOpName("SparseSegmentSqrtNWithNumSegments"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(indices.asOutput());
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 16e47ab2431..13bcf882abe 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along sparse segments of a tensor.
@@ -65,7 +65,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSum<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentSum<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSum operation.
@@ -77,7 +77,7 @@ public final class SparseSegmentSum<T extends TNumber> extends RawOp implements
    * @return a new instance of SparseSegmentSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> SparseSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSum", scope.makeOpName("SparseSegmentSum"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(indices.asOutput());
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 569d0c691c6..598d563c82b 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along sparse segments of a tensor.
@@ -63,7 +63,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSumWithNumSegments<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSegmentSumWithNumSegments<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSegmentSumWithNumSegments operation.
@@ -76,7 +76,7 @@ public final class SparseSegmentSumWithNumSegments<T extends TNumber> extends Ra
    * @return a new instance of SparseSegmentSumWithNumSegments
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSumWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSumWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSumWithNumSegments", scope.makeOpName("SparseSegmentSumWithNumSegments"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(indices.asOutput());
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 5c429a40d9a..bac75336e19 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Slice a `SparseTensor` based on the `start` and `size`.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSlice<T extends TType> extends RawOp {
+public final class SparseSlice<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSlice operation.
@@ -66,7 +66,7 @@ public final class SparseSlice<T extends TType> extends RawOp {
    * @return a new instance of SparseSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseSlice<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Operand<TInt64> start, Operand<TInt64> size) {
+  public static <T extends Tensor> SparseSlice<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Operand<TInt64> start, Operand<TInt64> size) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSlice", scope.makeOpName("SparseSlice"));
     opBuilder.addInput(indices.asOutput());
     opBuilder.addInput(values.asOutput());
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 172d8bd5816..dac276c44a3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * The gradient operator for the SparseSlice op.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code valGrad()} output
  */
 @Operator(group = "sparse")
-public final class SparseSliceGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseSliceGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSliceGrad operation.
@@ -52,7 +52,7 @@ public final class SparseSliceGrad<T extends TType> extends RawOp implements Ope
    * @return a new instance of SparseSliceGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseSliceGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> inputIndices, Operand<TInt64> inputStart, Operand<TInt64> outputIndices) {
+  public static <T extends Tensor> SparseSliceGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> inputIndices, Operand<TInt64> inputStart, Operand<TInt64> outputIndices) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSliceGrad", scope.makeOpName("SparseSliceGrad"));
     opBuilder.addInput(backpropValGrad.asOutput());
     opBuilder.addInput(inputIndices.asOutput());
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 ee37d13c818..c11466395b9 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies softmax to a batched N-D `SparseTensor`.
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSoftmax<T extends TNumber> extends RawOp implements Operand<T> {
+public final class SparseSoftmax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SparseSoftmax operation.
@@ -64,7 +64,7 @@ public final class SparseSoftmax<T extends TNumber> extends RawOp implements Ope
    * @return a new instance of SparseSoftmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SparseSoftmax<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape) {
+  public static <T extends Tensor & TNumber> SparseSoftmax<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSoftmax", scope.makeOpName("SparseSoftmax"));
     opBuilder.addInput(spIndices.asOutput());
     opBuilder.addInput(spValues.asOutput());
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 d6d86234578..ce987f487fe 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the element-wise max of two SparseTensors.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSparseMaximum<T extends TNumber> extends RawOp {
+public final class SparseSparseMaximum<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSparseMaximum operation.
@@ -53,7 +53,7 @@ public final class SparseSparseMaximum<T extends TNumber> extends RawOp {
    * @return a new instance of SparseSparseMaximum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> SparseSparseMaximum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
+  public static <T extends Tensor & TNumber> SparseSparseMaximum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSparseMaximum", scope.makeOpName("SparseSparseMaximum"));
     opBuilder.addInput(aIndices.asOutput());
     opBuilder.addInput(aValues.asOutput());
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 f46065ae9fc..2d376f040b7 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the element-wise min of two SparseTensors.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSparseMinimum<T extends TType> extends RawOp {
+public final class SparseSparseMinimum<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSparseMinimum operation.
@@ -52,7 +52,7 @@ public final class SparseSparseMinimum<T extends TType> extends RawOp {
    * @return a new instance of SparseSparseMinimum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseSparseMinimum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
+  public static <T extends Tensor> SparseSparseMinimum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSparseMinimum", scope.makeOpName("SparseSparseMinimum"));
     opBuilder.addInput(aIndices.asOutput());
     opBuilder.addInput(aValues.asOutput());
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 dee18e0e862..3e64b620a18 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Split a `SparseTensor` into `num_split` tensors along one dimension.
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSplit<T extends TType> extends RawOp {
+public final class SparseSplit<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSplit operation.
@@ -71,7 +71,7 @@ public final class SparseSplit<T extends TType> extends RawOp {
    * @return a new instance of SparseSplit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseSplit<T> create(Scope scope, Operand<TInt64> splitDim, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Long numSplit) {
+  public static <T extends Tensor> SparseSplit<T> create(Scope scope, Operand<TInt64> splitDim, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Long numSplit) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSplit", scope.makeOpName("SparseSplit"));
     opBuilder.addInput(splitDim.asOutput());
     opBuilder.addInput(indices.asOutput());
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 86f9d3394d1..c3b94de3eb5 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`.
@@ -36,7 +36,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseTensorDenseAdd<U extends TType> extends RawOp implements Operand<U> {
+public final class SparseTensorDenseAdd<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorDenseAdd operation.
@@ -49,7 +49,7 @@ public final class SparseTensorDenseAdd<U extends TType> extends RawOp implement
    * @return a new instance of SparseTensorDenseAdd
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> SparseTensorDenseAdd<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<T> aShape, Operand<U> b) {
+  public static <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseAdd<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<T> aShape, Operand<U> b) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorDenseAdd", scope.makeOpName("SparseTensorDenseAdd"));
     opBuilder.addInput(aIndices.asOutput());
     opBuilder.addInput(aValues.asOutput());
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 858bce58f73..142d6689591 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Multiply SparseTensor (of rank 2) "A" by dense matrix "B".
@@ -45,7 +45,7 @@
  * @param <U> data type for {@code product()} output
  */
 @Operator(group = "sparse")
-public final class SparseTensorDenseMatMul<U extends TType> extends RawOp implements Operand<U> {
+public final class SparseTensorDenseMatMul<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseTensorDenseMatMul}
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of SparseTensorDenseMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> SparseTensorDenseMatMul<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<TInt64> aShape, Operand<U> b, Options... options) {
+  public static <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseMatMul<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<TInt64> aShape, Operand<U> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorDenseMatMul", scope.makeOpName("SparseTensorDenseMatMul"));
     opBuilder.addInput(aIndices.asOutput());
     opBuilder.addInput(aValues.asOutput());
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 04b21e5d46e..5e238fd902e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts a sparse representation into a dense tensor.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code dense()} output
  */
 @Operator(group = "sparse")
-public final class SparseToDense<U extends TType> extends RawOp implements Operand<U> {
+public final class SparseToDense<U extends Tensor> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseToDense}
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of SparseToDense
    */
   @Endpoint(describeByClass = true)
-  public static <U extends TType, T extends TNumber> SparseToDense<U> create(Scope scope, Operand<T> sparseIndices, Operand<T> outputShape, Operand<U> sparseValues, Operand<U> defaultValue, Options... options) {
+  public static <U extends Tensor, T extends Tensor & TNumber> SparseToDense<U> create(Scope scope, Operand<T> sparseIndices, Operand<T> outputShape, Operand<U> sparseValues, Operand<U> defaultValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseToDense", scope.makeOpName("SparseToDense"));
     opBuilder.addInput(sparseIndices.asOutput());
     opBuilder.addInput(outputShape.asOutput());
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 3b606bbd6e9..2120f7c38df 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies set operation along last dimension of 2 `SparseTensor` inputs.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseToSparseSetOperation<T extends TType> extends RawOp {
+public final class SparseToSparseSetOperation<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseToSparseSetOperation}
@@ -102,7 +102,7 @@ private Options() {
    * @return a new instance of SparseToSparseSetOperation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SparseToSparseSetOperation<T> create(Scope scope, Operand<TInt64> set1Indices, Operand<T> set1Values, Operand<TInt64> set1Shape, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
+  public static <T extends Tensor> SparseToSparseSetOperation<T> create(Scope scope, Operand<TInt64> set1Indices, Operand<T> set1Values, Operand<TInt64> set1Shape, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseToSparseSetOperation", scope.makeOpName("SparseToSparseSetOperation"));
     opBuilder.addInput(set1Indices.asOutput());
     opBuilder.addInput(set1Values.asOutput());
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 8b38ac4f936..3a410449626 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Read `SparseTensors` from a `SparseTensorsMap` and concatenate them.
@@ -80,7 +80,7 @@
  * @param <T> data type for {@code sparseValues()} output
  */
 @Operator(group = "sparse")
-public final class TakeManySparseFromTensorsMap<T extends TType> extends RawOp {
+public final class TakeManySparseFromTensorsMap<T extends Tensor> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.TakeManySparseFromTensorsMap}
@@ -124,7 +124,7 @@ private Options() {
    * @return a new instance of TakeManySparseFromTensorsMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TakeManySparseFromTensorsMap<T> create(Scope scope, Operand<TInt64> sparseHandles, DataType<T> dtype, Options... options) {
+  public static <T extends Tensor> TakeManySparseFromTensorsMap<T> create(Scope scope, Operand<TInt64> sparseHandles, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TakeManySparseFromTensorsMap", scope.makeOpName("TakeManySparseFromTensorsMap"));
     opBuilder.addInput(sparseHandles.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 e54a46a6b69..ea84605c368 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Creates ngrams from ragged string data.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code ngramsSplits()} output
  */
 @Operator(group = "strings")
-public final class StringNGrams<T extends TNumber> extends RawOp {
+public final class StringNGrams<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new StringNGrams operation.
@@ -63,7 +63,7 @@ public final class StringNGrams<T extends TNumber> extends RawOp {
    * @return a new instance of StringNGrams
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> StringNGrams<T> create(Scope scope, Operand<TString> data, Operand<T> dataSplits, String separator, List<Long> ngramWidths, String leftPad, String rightPad, Long padWidth, Boolean preserveShortSequences) {
+  public static <T extends Tensor & TNumber> StringNGrams<T> create(Scope scope, Operand<TString> data, Operand<T> dataSplits, String separator, List<Long> ngramWidths, String leftPad, String rightPad, Long padWidth, Boolean preserveShortSequences) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringNGrams", scope.makeOpName("StringNGrams"));
     opBuilder.addInput(data.asOutput());
     opBuilder.addInput(dataSplits.asOutput());
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 9d6e21cbafc..520a5c9542e 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Return substrings from `Tensor` of strings.
@@ -145,7 +145,7 @@ private Options() {
    * @return a new instance of Substr
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> Substr create(Scope scope, Operand<TString> input, Operand<T> pos, Operand<T> len, Options... options) {
+  public static <T extends Tensor & TNumber> Substr create(Scope scope, Operand<TString> input, Operand<T> pos, Operand<T> len, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Substr", scope.makeOpName("Substr"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(pos.asOutput());
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 8c0751ea782..bf77911551a 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -29,7 +30,6 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Converts each string in the input Tensor to the specified numeric type.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "strings")
-public final class ToNumber<T extends TNumber> extends RawOp implements Operand<T> {
+public final class ToNumber<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ToNumber operation.
@@ -58,7 +58,7 @@ public final class ToNumber<T extends TNumber> extends RawOp implements Operand<
    * @return a new instance of ToNumber
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ToNumber<T> create(Scope scope, Operand<TString> stringTensor, DataType<T> outType) {
+  public static <T extends Tensor & TNumber> ToNumber<T> create(Scope scope, Operand<TString> stringTensor, DataType<T> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringToNumber", scope.makeOpName("ToNumber"));
     opBuilder.addInput(stringTensor.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1d5f077d04b..a4201a1be21 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -30,7 +31,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Decodes each string in `input` into a sequence of Unicode code points.
@@ -54,7 +54,7 @@
  * 
  * @param <T> data type for {@code rowSplits()} output
  */
-public final class UnicodeDecode<T extends TNumber> extends RawOp {
+public final class UnicodeDecode<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeDecode}
@@ -116,7 +116,7 @@ private Options() {
    * @return a new instance of UnicodeDecode
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> UnicodeDecode<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
+  public static <T extends Tensor & TNumber> UnicodeDecode<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeDecode", scope.makeOpName("UnicodeDecode"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 019afa8fe33..a1feac2fd3c 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,6 +22,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -30,7 +31,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Decodes each string in `input` into a sequence of Unicode code points.
@@ -60,7 +60,7 @@
  * 
  * @param <T> data type for {@code rowSplits()} output
  */
-public final class UnicodeDecodeWithOffsets<T extends TNumber> extends RawOp {
+public final class UnicodeDecodeWithOffsets<T extends Tensor & TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeDecodeWithOffsets}
@@ -122,7 +122,7 @@ private Options() {
    * @return a new instance of UnicodeDecodeWithOffsets
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> UnicodeDecodeWithOffsets<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
+  public static <T extends Tensor & TNumber> UnicodeDecodeWithOffsets<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeDecodeWithOffsets", scope.makeOpName("UnicodeDecodeWithOffsets"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 1a539366d81..b7fb132260f 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Encode a tensor of ints into unicode strings.
@@ -102,7 +102,7 @@ private Options() {
    * @return a new instance of UnicodeEncode
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> UnicodeEncode create(Scope scope, Operand<TInt32> inputValues, Operand<T> inputSplits, String outputEncoding, Options... options) {
+  public static <T extends Tensor & TNumber> UnicodeEncode create(Scope scope, Operand<TInt32> inputValues, Operand<T> inputSplits, String outputEncoding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeEncode", scope.makeOpName("UnicodeEncode"));
     opBuilder.addInput(inputValues.asOutput());
     opBuilder.addInput(inputSplits.asOutput());
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 47043fac5b2..a6cffe58bcc 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Joins the elements of `inputs` based on `segment_ids`.
@@ -93,7 +93,7 @@ private Options() {
    * @return a new instance of UnsortedSegmentJoin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber> UnsortedSegmentJoin create(Scope scope, Operand<TString> inputs, Operand<T> segmentIds, Operand<U> numSegments, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> UnsortedSegmentJoin create(Scope scope, Operand<TString> inputs, Operand<T> segmentIds, Operand<U> numSegments, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentJoin", scope.makeOpName("UnsortedSegmentJoin"));
     opBuilder.addInput(inputs.asOutput());
     opBuilder.addInput(segmentIds.asOutput());
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 c98efad5b3b..9a4b70596a2 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs a `Summary` protocol buffer with a histogram.
@@ -50,7 +50,7 @@ public final class HistogramSummary extends RawOp implements Operand<TString> {
    * @return a new instance of HistogramSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> HistogramSummary create(Scope scope, Operand<TString> tag, Operand<T> values) {
+  public static <T extends Tensor & TNumber> HistogramSummary create(Scope scope, Operand<TString> tag, Operand<T> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("HistogramSummary", scope.makeOpName("HistogramSummary"));
     opBuilder.addInput(tag.asOutput());
     opBuilder.addInput(values.asOutput());
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 50cc52f5769..4f0adcdf4b0 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
@@ -28,7 +28,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs a `Summary` protocol buffer with images.
@@ -122,7 +121,7 @@ private Options() {
    * @return a new instance of ImageSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ImageSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Options... options) {
+  public static <T extends Tensor & TNumber> ImageSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ImageSummary", scope.makeOpName("ImageSummary"));
     opBuilder.addInput(tag.asOutput());
     opBuilder.addInput(tensor.asOutput());
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 c766d9759ed..20fed2d4d5c 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs a `Summary` protocol buffer with scalar values.
@@ -47,7 +47,7 @@ public final class ScalarSummary extends RawOp implements Operand<TString> {
    * @return a new instance of ScalarSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> ScalarSummary create(Scope scope, Operand<TString> tags, Operand<T> values) {
+  public static <T extends Tensor & TNumber> ScalarSummary create(Scope scope, Operand<TString> tags, Operand<T> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScalarSummary", scope.makeOpName("ScalarSummary"));
     opBuilder.addInput(tags.asOutput());
     opBuilder.addInput(values.asOutput());
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 f27b996b716..3a1e03afea5 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SummaryWriter extends RawOp implements Operand<TType> {
+public final class SummaryWriter extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.summary.SummaryWriter}
@@ -105,8 +105,8 @@ public Output<?> writer() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) writer;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) writer;
   }
   
   private Output<?> writer;
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 0d6e950a4f3..ed7ac378d5c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Outputs a `Summary` protocol buffer with a tensor and per-plugin data.
@@ -45,7 +45,7 @@ public final class TensorSummary extends RawOp implements Operand<TString> {
    * @return a new instance of TensorSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TensorSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Operand<TString> serializedSummaryMetadata) {
+  public static <T extends Tensor> TensorSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Operand<TString> serializedSummaryMetadata) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorSummaryV2", scope.makeOpName("TensorSummary"));
     opBuilder.addInput(tag.asOutput());
     opBuilder.addInput(tensor.asOutput());
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 1cfdc6bd095..a5d7fe41127 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,6 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -27,7 +28,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -44,7 +44,7 @@ public final class WriteHistogramSummary extends RawOp {
    * @return a new instance of WriteHistogramSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> WriteHistogramSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> values) {
+  public static <T extends Tensor & TNumber> WriteHistogramSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteHistogramSummary", scope.makeOpName("WriteHistogramSummary"));
     opBuilder.addInput(writer.asOutput());
     opBuilder.addInput(step.asOutput());
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 26be4538bf0..18dac4290f3 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,6 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -28,7 +29,6 @@
 import org.tensorflow.types.TString;
 import org.tensorflow.types.TUint8;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -66,7 +66,7 @@ private Options() {
    * @return a new instance of WriteImageSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> WriteImageSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> tensor, Operand<TUint8> badColor, Options... options) {
+  public static <T extends Tensor & TNumber> WriteImageSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> tensor, Operand<TUint8> badColor, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteImageSummary", scope.makeOpName("WriteImageSummary"));
     opBuilder.addInput(writer.asOutput());
     opBuilder.addInput(step.asOutput());
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 b3a7b3a6723..1eed2c27f17 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,6 +20,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -27,7 +28,6 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -44,7 +44,7 @@ public final class WriteScalarSummary extends RawOp {
    * @return a new instance of WriteScalarSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> WriteScalarSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> value) {
+  public static <T extends Tensor & TNumber> WriteScalarSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteScalarSummary", scope.makeOpName("WriteScalarSummary"));
     opBuilder.addInput(writer.asOutput());
     opBuilder.addInput(step.asOutput());
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 a538b5a4cfd..93c83d7cf6f 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -44,7 +44,7 @@ public final class WriteSummary extends RawOp {
    * @return a new instance of WriteSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> WriteSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<T> tensor, Operand<TString> tag, Operand<TString> summaryMetadata) {
+  public static <T extends Tensor> WriteSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<T> tensor, Operand<TString> tag, Operand<TString> summaryMetadata) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteSummary", scope.makeOpName("WriteSummary"));
     opBuilder.addInput(writer.asOutput());
     opBuilder.addInput(step.asOutput());
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 615657b1408..2ab39e2c393 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * An Op to exchange data across TPU replicas.
@@ -50,7 +50,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AllToAll<T extends TType> extends RawOp implements Operand<T> {
+public final class AllToAll<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AllToAll operation.
@@ -67,7 +67,7 @@ public final class AllToAll<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of AllToAll
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AllToAll<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment, Long concatDimension, Long splitDimension, Long splitCount) {
+  public static <T extends Tensor> AllToAll<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment, Long concatDimension, Long splitDimension, Long splitCount) {
     OperationBuilder opBuilder = scope.env().opBuilder("AllToAll", scope.makeOpName("AllToAll"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(groupAssignment.asOutput());
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 5b298bc1630..d12c4a0d167 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * An Op to permute tensors across replicated TPU instances.
@@ -39,7 +39,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CollectivePermute<T extends TType> extends RawOp implements Operand<T> {
+public final class CollectivePermute<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CollectivePermute operation.
@@ -51,7 +51,7 @@ public final class CollectivePermute<T extends TType> extends RawOp implements O
    * @return a new instance of CollectivePermute
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> CollectivePermute<T> create(Scope scope, Operand<T> input, Operand<TInt32> sourceTargetPairs) {
+  public static <T extends Tensor> CollectivePermute<T> create(Scope scope, Operand<T> input, Operand<TInt32> sourceTargetPairs) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectivePermute", scope.makeOpName("CollectivePermute"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(sourceTargetPairs.asOutput());
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 2c257fb6d2f..2e5c63f42fa 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An Op to sum inputs across replicated TPU instances.
@@ -41,7 +41,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CrossReplicaSum<T extends TNumber> extends RawOp implements Operand<T> {
+public final class CrossReplicaSum<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new CrossReplicaSum operation.
@@ -54,7 +54,7 @@ public final class CrossReplicaSum<T extends TNumber> extends RawOp implements O
    * @return a new instance of CrossReplicaSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber> CrossReplicaSum<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment) {
+  public static <T extends Tensor & TNumber> CrossReplicaSum<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment) {
     OperationBuilder opBuilder = scope.env().opBuilder("CrossReplicaSum", scope.makeOpName("CrossReplicaSum"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(groupAssignment.asOutput());
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 35185704d89..f5078ce2b82 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
@@ -21,6 +21,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -28,7 +29,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An op that enqueues TPUEmbedding input indices from a SparseTensor.
@@ -99,7 +99,7 @@ private Options() {
    * @return a new instance of EnqueueTPUEmbeddingSparseBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> EnqueueTPUEmbeddingSparseBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> EnqueueTPUEmbeddingSparseBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EnqueueTPUEmbeddingSparseBatch", scope.makeOpName("EnqueueTPUEmbeddingSparseBatch"));
     opBuilder.addInputList(Operands.asOutputs(sampleIndices));
     opBuilder.addInputList(Operands.asOutputs(embeddingIndices));
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 5e4bf1c6b27..e682e0b4ccf 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
@@ -21,6 +21,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -28,7 +29,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Eases the porting of code that uses tf.nn.embedding_lookup_sparse().
@@ -112,7 +112,7 @@ private Options() {
    * @return a new instance of EnqueueTPUEmbeddingSparseTensorBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TNumber, V extends TNumber> EnqueueTPUEmbeddingSparseTensorBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, List<Long> tableIds, Options... options) {
+  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> EnqueueTPUEmbeddingSparseTensorBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, List<Long> tableIds, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EnqueueTPUEmbeddingSparseTensorBatch", scope.makeOpName("EnqueueTPUEmbeddingSparseTensorBatch"));
     opBuilder.addInputList(Operands.asOutputs(sampleIndices));
     opBuilder.addInputList(Operands.asOutputs(embeddingIndices));
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 19a5528dd5d..439716f8f74 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A placeholder op for a value that will be fed into the computation.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class InfeedDequeue<T extends TType> extends RawOp implements Operand<T> {
+public final class InfeedDequeue<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new InfeedDequeue operation.
@@ -45,7 +45,7 @@ public final class InfeedDequeue<T extends TType> extends RawOp implements Opera
    * @return a new instance of InfeedDequeue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> InfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape) {
+  public static <T extends Tensor> InfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("InfeedDequeue", scope.makeOpName("InfeedDequeue"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
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 3e9fe720ca9..35182bdcaf5 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,17 +25,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Fetches multiple values from infeed as an XLA tuple.
  */
-public final class InfeedDequeueTuple extends RawOp implements Iterable<Operand<TType>> {
+public final class InfeedDequeueTuple extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new InfeedDequeueTuple operation.
@@ -71,7 +71,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 f40a1b7c5c4..61b6f813b57 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,12 +21,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * An op which feeds a single Tensor value into the computation.
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of InfeedEnqueue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> InfeedEnqueue create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> InfeedEnqueue create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("InfeedEnqueue", scope.makeOpName("InfeedEnqueue"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 2e822837449..789fa6f4c29 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Retrieves a single tensor from the computation outfeed.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class OutfeedDequeue<T extends TType> extends RawOp implements Operand<T> {
+public final class OutfeedDequeue<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.OutfeedDequeue}
@@ -69,7 +69,7 @@ private Options() {
    * @return a new instance of OutfeedDequeue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> OutfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends Tensor> OutfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OutfeedDequeue", scope.makeOpName("OutfeedDequeue"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
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 b7c2f10fcac..5692bd12a26 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Retrieve multiple values from the computation outfeed.
@@ -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 RawOp implements Iterable<Operand<TType>> {
+public final class OutfeedDequeueTuple extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.OutfeedDequeueTuple}
@@ -112,7 +112,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 16e8733bc55..6de5bc99f6c 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Enqueue a Tensor on the computation outfeed.
@@ -39,7 +39,7 @@ public final class OutfeedEnqueue extends RawOp {
    * @return a new instance of OutfeedEnqueue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> OutfeedEnqueue create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> OutfeedEnqueue create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("OutfeedEnqueue", scope.makeOpName("OutfeedEnqueue"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 78b0e38f4ae..8784472e132 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,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * An op which linearizes one Tensor value to an opaque variant tensor.
  */
-public final class Prelinearize extends RawOp implements Operand<TType> {
+public final class Prelinearize extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.Prelinearize}
@@ -73,7 +73,7 @@ private Options() {
    * @return a new instance of Prelinearize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Prelinearize create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> Prelinearize create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Prelinearize", scope.makeOpName("Prelinearize"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
@@ -118,8 +118,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 cc5a77b7fe4..3b175591149 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
@@ -22,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * An op which linearizes multiple Tensor values to an opaque variant tensor.
  */
-public final class PrelinearizeTuple extends RawOp implements Operand<TType> {
+public final class PrelinearizeTuple extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.PrelinearizeTuple}
@@ -108,8 +108,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) output;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) output;
   }
   
   private Output<?> output;
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 157cb366d65..69faf3195bb 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Connects N inputs to an N-way replicated TPU computation.
@@ -45,7 +45,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TPUReplicatedInput<T extends TType> extends RawOp implements Operand<T> {
+public final class TPUReplicatedInput<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.TPUReplicatedInput}
@@ -84,7 +84,7 @@ private Options() {
    * @return a new instance of TPUReplicatedInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TPUReplicatedInput<T> create(Scope scope, Iterable<Operand<T>> inputs, Options... options) {
+  public static <T extends Tensor> TPUReplicatedInput<T> create(Scope scope, Iterable<Operand<T>> inputs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TPUReplicatedInput", scope.makeOpName("TPUReplicatedInput"));
     opBuilder.addInputList(Operands.asOutputs(inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
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 0c169b3008d..06b0a67c110 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,11 +24,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Connects N outputs from an N-way replicated TPU computation.
@@ -45,7 +45,7 @@
  * 
  * @param <T> data type for {@code outputs()} output
  */
-public final class TPUReplicatedOutput<T extends TType> extends RawOp implements Iterable<Operand<T>> {
+public final class TPUReplicatedOutput<T extends Tensor> extends RawOp implements Iterable<Operand<T>> {
   
   /**
    * Factory method to create a class wrapping a new TPUReplicatedOutput operation.
@@ -56,7 +56,7 @@ public final class TPUReplicatedOutput<T extends TType> extends RawOp implements
    * @return a new instance of TPUReplicatedOutput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TPUReplicatedOutput<T> create(Scope scope, Operand<T> input, Long numReplicas) {
+  public static <T extends Tensor> TPUReplicatedOutput<T> create(Scope scope, Operand<T> input, Long numReplicas) {
     OperationBuilder opBuilder = scope.env().opBuilder("TPUReplicatedOutput", scope.makeOpName("TPUReplicatedOutput"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 c493d6daa72..275d0b3f949 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies a gradient to a given accumulator.
@@ -46,7 +46,7 @@ public final class AccumulatorApplyGradient extends RawOp {
    * @return a new instance of AccumulatorApplyGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<T> gradient) {
+  public static <T extends Tensor> AccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<T> gradient) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulatorApplyGradient", scope.makeOpName("AccumulatorApplyGradient"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(localStep.asOutput());
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 23f24d3f675..af651a85bab 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Extracts the average gradient in the given ConditionalAccumulator.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code average()} output
  */
 @Operator(group = "train")
-public final class AccumulatorTakeGradient<T extends TType> extends RawOp implements Operand<T> {
+public final class AccumulatorTakeGradient<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new AccumulatorTakeGradient operation.
@@ -55,7 +55,7 @@ public final class AccumulatorTakeGradient<T extends TType> extends RawOp implem
    * @return a new instance of AccumulatorTakeGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> AccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
+  public static <T extends Tensor> AccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulatorTakeGradient", scope.makeOpName("AccumulatorTakeGradient"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(numRequired.asOutput());
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 8153a364508..3c5c464909c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AdaMax algorithm.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class ApplyAdaMax<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyAdaMax<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdaMax}
@@ -76,7 +76,7 @@ private Options() {
    * @return a new instance of ApplyAdaMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyAdaMax<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyAdaMax<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdaMax", scope.makeOpName("ApplyAdaMax"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 928e2ae0f4e..cde20b21955 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adadelta scheme.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdadelta<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyAdadelta<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdadelta}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of ApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdadelta", scope.makeOpName("ApplyAdadelta"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 2a88b987503..7986b5c21d8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adagrad scheme.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdagrad<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagrad}
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of ApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdagrad", scope.makeOpName("ApplyAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 e03d521353b..01620ddc4c6 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the proximal adagrad scheme.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdagradDa<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyAdagradDa<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagradDa}
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of ApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends Tensor> ApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdagradDA", scope.makeOpName("ApplyAdagradDa"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(gradientAccumulator.asOutput());
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 aeaaddb103c..d3053291e23 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adagrad scheme.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class ApplyAdagradV2<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyAdagradV2<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagradV2}
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of ApplyAdagradV2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyAdagradV2<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyAdagradV2<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdagradV2", scope.makeOpName("ApplyAdagradV2"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 c6b93126708..6f5cb1b5f0a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Adam algorithm.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdam<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyAdam<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdam}
@@ -88,7 +88,7 @@ private Options() {
    * @return a new instance of ApplyAdam
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyAdam<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyAdam<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdam", scope.makeOpName("ApplyAdam"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 d7ca57e1dce..2d816ff8f5f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAddSign<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyAddSign<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAddSign}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of ApplyAddSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyAddSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyAddSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAddSign", scope.makeOpName("ApplyAddSign"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 fb1735ca92c..52ed6d9805b 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyCenteredRmsProp<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyCenteredRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyCenteredRmsProp}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of ApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyCenteredRMSProp", scope.makeOpName("ApplyCenteredRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(mg.asOutput());
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 54c9cab7494..130da063347 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Ftrl-proximal scheme.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyFtrl<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyFtrl<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyFtrl}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of ApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends Tensor> ApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyFtrlV2", scope.makeOpName("ApplyFtrl"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 8377b0594e0..e0311439aca 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' by subtracting 'alpha' * 'delta' from it.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyGradientDescent<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyGradientDescent<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyGradientDescent}
@@ -66,7 +66,7 @@ private Options() {
    * @return a new instance of ApplyGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> delta, Options... options) {
+  public static <T extends Tensor> ApplyGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyGradientDescent", scope.makeOpName("ApplyGradientDescent"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(alpha.asOutput());
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 dbd26f4eb9c..8814aea9d82 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the momentum scheme.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyMomentum<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyMomentum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyMomentum}
@@ -85,7 +85,7 @@ private Options() {
    * @return a new instance of ApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
+  public static <T extends Tensor> ApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyMomentum", scope.makeOpName("ApplyMomentum"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 c0332c9a840..176797e65a5 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyPowerSign<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyPowerSign<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyPowerSign}
@@ -75,7 +75,7 @@ private Options() {
    * @return a new instance of ApplyPowerSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyPowerSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyPowerSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyPowerSign", scope.makeOpName("ApplyPowerSign"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 0f3e9af018a..5eb77848587 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyProximalAdagrad<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyProximalAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyProximalAdagrad}
@@ -73,7 +73,7 @@ private Options() {
    * @return a new instance of ApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyProximalAdagrad", scope.makeOpName("ApplyProximalAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 7a28929d7e7..2845d9dcf35 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' as FOBOS algorithm with fixed learning rate.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyProximalGradientDescent<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyProximalGradientDescent<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyProximalGradientDescent}
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of ApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
+  public static <T extends Tensor> ApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyProximalGradientDescent", scope.makeOpName("ApplyProximalGradientDescent"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(alpha.asOutput());
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 53ff4e45b87..c62b03b3fb9 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyRmsProp<T extends TType> extends RawOp implements Operand<T> {
+public final class ApplyRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyRmsProp}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of ApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyRMSProp", scope.makeOpName("ApplyRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(ms.asOutput());
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 6e1ae852143..898d26681e6 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Multiplies slices of two tensors in batches.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class BatchMatMul<T extends TType> extends RawOp implements Operand<T> {
+public final class BatchMatMul<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.BatchMatMul}
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of BatchMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> BatchMatMul<T> create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends Tensor> BatchMatMul<T> create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatMulV2", scope.makeOpName("BatchMatMul"));
     opBuilder.addInput(x.asOutput());
     opBuilder.addInput(y.asOutput());
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 3708f037741..c8cf08b77f3 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * A conditional accumulator for aggregating gradients.
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of ConditionalAccumulator
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends Tensor> ConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConditionalAccumulator", scope.makeOpName("ConditionalAccumulator"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
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 cbd17d82d2d..af24d35e0eb 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * An identity op that triggers an error if a gradient is requested.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class PreventGradient<T extends TType> extends RawOp implements Operand<T> {
+public final class PreventGradient<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.PreventGradient}
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of PreventGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> PreventGradient<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends Tensor> PreventGradient<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("PreventGradient", scope.makeOpName("PreventGradient"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
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 ee76a499d06..42f7fafabf8 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Applies a gradient to a given accumulator.
@@ -44,7 +44,7 @@ public final class ResourceAccumulatorApplyGradient extends RawOp {
    * @return a new instance of ResourceAccumulatorApplyGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceAccumulatorApplyGradient create(Scope scope, Operand<?> handle, Operand<TInt64> localStep, Operand<T> gradient) {
+  public static <T extends Tensor> ResourceAccumulatorApplyGradient create(Scope scope, Operand<?> handle, Operand<TInt64> localStep, Operand<T> gradient) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceAccumulatorApplyGradient", scope.makeOpName("ResourceAccumulatorApplyGradient"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(localStep.asOutput());
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 ab334ce4cc0..57790d28a48 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Extracts the average gradient in the given ConditionalAccumulator.
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code average()} output
  */
-public final class ResourceAccumulatorTakeGradient<T extends TType> extends RawOp implements Operand<T> {
+public final class ResourceAccumulatorTakeGradient<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ResourceAccumulatorTakeGradient operation.
@@ -53,7 +53,7 @@ public final class ResourceAccumulatorTakeGradient<T extends TType> extends RawO
    * @return a new instance of ResourceAccumulatorTakeGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceAccumulatorTakeGradient<T> create(Scope scope, Operand<?> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
+  public static <T extends Tensor> ResourceAccumulatorTakeGradient<T> create(Scope scope, Operand<?> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceAccumulatorTakeGradient", scope.makeOpName("ResourceAccumulatorTakeGradient"));
     opBuilder.addInput(handle.asOutput());
     opBuilder.addInput(numRequired.asOutput());
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 c22944b05c8..d23e9fe9654 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AdaMax algorithm.
@@ -73,7 +73,7 @@ private Options() {
    * @return a new instance of ResourceApplyAdaMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyAdaMax create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyAdaMax create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdaMax", scope.makeOpName("ResourceApplyAdaMax"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 8a947bc150e..61154791d29 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adadelta scheme.
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of ResourceApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdadelta", scope.makeOpName("ResourceApplyAdadelta"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 33ae02d0f59..b629e1b4106 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adagrad scheme.
@@ -77,7 +77,7 @@ private Options() {
    * @return a new instance of ResourceApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdagradV2", scope.makeOpName("ResourceApplyAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 ffb77721112..b636b6b4473 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the proximal adagrad scheme.
@@ -69,7 +69,7 @@ private Options() {
    * @return a new instance of ResourceApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends Tensor> ResourceApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdagradDA", scope.makeOpName("ResourceApplyAdagradDa"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(gradientAccumulator.asOutput());
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 8c68669fc92..50e2aa8d21b 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Adam algorithm.
@@ -85,7 +85,7 @@ private Options() {
    * @return a new instance of ResourceApplyAdam
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyAdam create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyAdam create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdam", scope.makeOpName("ResourceApplyAdam"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 86dcc2d06ef..c081212e9eb 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Adam algorithm.
@@ -78,7 +78,7 @@ private Options() {
    * @return a new instance of ResourceApplyAdamWithAmsgrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyAdamWithAmsgrad create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyAdamWithAmsgrad create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdamWithAmsgrad", scope.makeOpName("ResourceApplyAdamWithAmsgrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 82489d348da..6bfcd2914cf 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of ResourceApplyAddSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyAddSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyAddSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAddSign", scope.makeOpName("ResourceApplyAddSign"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 d76224d6022..f1edd1a6ad1 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of ResourceApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyCenteredRMSProp", scope.makeOpName("ResourceApplyCenteredRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(mg.asOutput());
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 7add86848c9..5bc0109d1f1 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Ftrl-proximal scheme.
@@ -78,7 +78,7 @@ private Options() {
    * @return a new instance of ResourceApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends Tensor> ResourceApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyFtrlV2", scope.makeOpName("ResourceApplyFtrl"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 a57d2e90a18..014a3368830 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' by subtracting 'alpha' * 'delta' from it.
@@ -63,7 +63,7 @@ private Options() {
    * @return a new instance of ResourceApplyGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> delta, Options... options) {
+  public static <T extends Tensor> ResourceApplyGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyGradientDescent", scope.makeOpName("ResourceApplyGradientDescent"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(alpha.asOutput());
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 e58fd2150cd..f98c43d6e7f 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the momentum scheme.
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of ResourceApplyKerasMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
+  public static <T extends Tensor> ResourceApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyKerasMomentum", scope.makeOpName("ResourceApplyKerasMomentum"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 51af89430d2..8580aae6b55 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the momentum scheme. Set use_nesterov = True if you
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of ResourceApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
+  public static <T extends Tensor> ResourceApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyMomentum", scope.makeOpName("ResourceApplyMomentum"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 5f035f53935..738a507d64d 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of ResourceApplyPowerSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyPowerSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyPowerSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyPowerSign", scope.makeOpName("ResourceApplyPowerSign"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(m.asOutput());
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 e2197540e94..dac94fe5247 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of ResourceApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyProximalAdagrad", scope.makeOpName("ResourceApplyProximalAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 d5b9d063a95..1417a6a4608 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' as FOBOS algorithm with fixed learning rate.
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of ResourceApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
+  public static <T extends Tensor> ResourceApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyProximalGradientDescent", scope.makeOpName("ResourceApplyProximalGradientDescent"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(alpha.asOutput());
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 f79a1202f6a..18c61ef913f 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of ResourceApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends Tensor> ResourceApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyRMSProp", scope.makeOpName("ResourceApplyRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(ms.asOutput());
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 fe27517dee2..cea45b1773f 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * A conditional accumulator for aggregating gradients.
@@ -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 RawOp implements Operand<TType> {
+public final class ResourceConditionalAccumulator extends RawOp implements Operand<Tensor> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceConditionalAccumulator}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of ResourceConditionalAccumulator
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ResourceConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends Tensor> ResourceConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceConditionalAccumulator", scope.makeOpName("ResourceConditionalAccumulator"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -145,8 +145,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<TType> asOutput() {
-    return (Output<TType>) handle;
+  public Output<Tensor> asOutput() {
+    return (Output<Tensor>) handle;
   }
   
   private Output<?> handle;
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 d64efcb9474..1f228220913 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * var: Should be from a Variable().
@@ -69,7 +69,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdadelta", scope.makeOpName("ResourceSparseApplyAdadelta"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 6ece72cb637..92a826eac98 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdagrad", scope.makeOpName("ResourceSparseApplyAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 ad007159e6a..f7864e0354d 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdagradDA", scope.makeOpName("ResourceSparseApplyAdagradDa"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(gradientAccumulator.asOutput());
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 f8808aa3980..0fa87d30eaa 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
@@ -80,7 +80,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdagradV2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdagradV2 create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagradV2 create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdagradV2", scope.makeOpName("ResourceSparseApplyAdagradV2"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 e9482879729..8ac7e4f256e 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyCenteredRMSProp", scope.makeOpName("ResourceSparseApplyCenteredRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(mg.asOutput());
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 07f2e12f9b0..3f5dd1f689c 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' according to the Ftrl-proximal scheme.
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyFtrlV2", scope.makeOpName("ResourceSparseApplyFtrl"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 e1ff036c295..81039e15944 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the momentum scheme.
@@ -86,7 +86,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyKerasMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyKerasMomentum", scope.makeOpName("ResourceSparseApplyKerasMomentum"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 80c58d282bc..20400243d25 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the momentum scheme.
@@ -86,7 +86,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyMomentum", scope.makeOpName("ResourceSparseApplyMomentum"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 75e7ca9e0f1..442dd8c2c78 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyProximalAdagrad", scope.makeOpName("ResourceSparseApplyProximalAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 bf48496179c..f6ba86b72d4 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update '*var' as FOBOS algorithm with fixed learning rate.
@@ -71,7 +71,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyProximalGradientDescent", scope.makeOpName("ResourceSparseApplyProximalGradientDescent"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(alpha.asOutput());
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 0dc980bb6f8..4ee32e76a21 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of ResourceSparseApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> ResourceSparseApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyRMSProp", scope.makeOpName("ResourceSparseApplyRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(ms.asOutput());
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 ecd4a059793..6377fc831d2 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Restores tensors from a V2 checkpoint.
@@ -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 RawOp implements Iterable<Operand<TType>> {
+public final class Restore extends RawOp implements Iterable<Operand<Tensor>> {
   
   /**
    * Factory method to create a class wrapping a new Restore operation.
@@ -89,7 +89,7 @@ public List<Output<?>> tensors() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<TType>> iterator() {
+  public Iterator<Operand<Tensor>> iterator() {
     return (Iterator) tensors.iterator();
   }
   
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 e1148129d86..3aeee88ef68 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TType;
 
 /**
  * Restores a tensor from checkpoint files.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator(group = "train")
-public final class RestoreSlice<T extends TType> extends RawOp implements Operand<T> {
+public final class RestoreSlice<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.RestoreSlice}
@@ -79,7 +79,7 @@ private Options() {
    * @return a new instance of RestoreSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> RestoreSlice<T> create(Scope scope, Operand<TString> filePattern, Operand<TString> tensorName, Operand<TString> shapeAndSlice, DataType<T> dt, Options... options) {
+  public static <T extends Tensor> RestoreSlice<T> create(Scope scope, Operand<TString> filePattern, Operand<TString> tensorName, Operand<TString> shapeAndSlice, DataType<T> dt, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RestoreSlice", scope.makeOpName("RestoreSlice"));
     opBuilder.addInput(filePattern.asOutput());
     opBuilder.addInput(tensorName.asOutput());
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 6ed5c2faee3..d35d1985174 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * var: Should be from a Variable().
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyAdadelta<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyAdadelta<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdadelta}
@@ -72,7 +72,7 @@ private Options() {
    * @return a new instance of SparseApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyAdadelta", scope.makeOpName("SparseApplyAdadelta"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 90cbe36a32d..2d08b2cde13 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class SparseApplyAdagrad<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdagrad}
@@ -83,7 +83,7 @@ private Options() {
    * @return a new instance of SparseApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyAdagradV2", scope.makeOpName("SparseApplyAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 23c791a6d50..5a5fcf03093 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyAdagradDa<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyAdagradDa<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdagradDa}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of SparseApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyAdagradDA", scope.makeOpName("SparseApplyAdagradDa"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(gradientAccumulator.asOutput());
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 367de145c5e..19513a28693 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyCenteredRmsProp<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyCenteredRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyCenteredRmsProp}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of SparseApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyCenteredRMSProp", scope.makeOpName("SparseApplyCenteredRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(mg.asOutput());
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 defb68856e6..fe6e7b6b248 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' according to the Ftrl-proximal scheme.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyFtrl<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyFtrl<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyFtrl}
@@ -84,7 +84,7 @@ private Options() {
    * @return a new instance of SparseApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyFtrlV2", scope.makeOpName("SparseApplyFtrl"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 ebd4d0e7c14..fb6a4fd1eb5 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the momentum scheme.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyMomentum<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyMomentum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyMomentum}
@@ -89,7 +89,7 @@ private Options() {
    * @return a new instance of SparseApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyMomentum", scope.makeOpName("SparseApplyMomentum"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 0a73d0a138c..7d73ebe6ee1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyProximalAdagrad<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyProximalAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyProximalAdagrad}
@@ -77,7 +77,7 @@ private Options() {
    * @return a new instance of SparseApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyProximalAdagrad", scope.makeOpName("SparseApplyProximalAdagrad"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(accum.asOutput());
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 2a4ef9f900b..41b24e50b88 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update '*var' as FOBOS algorithm with fixed learning rate.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyProximalGradientDescent<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyProximalGradientDescent<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyProximalGradientDescent}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of SparseApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyProximalGradientDescent", scope.makeOpName("SparseApplyProximalGradientDescent"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(alpha.asOutput());
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 5205086b7dd..1481b9cf04c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyRmsProp<T extends TType> extends RawOp implements Operand<T> {
+public final class SparseApplyRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyRmsProp}
@@ -85,7 +85,7 @@ private Options() {
    * @return a new instance of SparseApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> SparseApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyRMSProp", scope.makeOpName("SparseApplyRmsProp"));
     opBuilder.addInput(var.asOutput());
     opBuilder.addInput(ms.asOutput());
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 42d68f0f59b..01430a5a737 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /**
  * Returns the gradient of `Tile`.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class TileGrad<T extends TType> extends RawOp implements Operand<T> {
+public final class TileGrad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new TileGrad operation.
@@ -49,7 +49,7 @@ public final class TileGrad<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of TileGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> TileGrad<T> create(Scope scope, Operand<T> input, Operand<TInt32> multiples) {
+  public static <T extends Tensor> TileGrad<T> create(Scope scope, Operand<T> input, Operand<TInt32> multiples) {
     OperationBuilder opBuilder = scope.env().opBuilder("TileGrad", scope.makeOpName("TileGrad"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(multiples.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java
index 1d8b4fe476b..bd9a7c2f576 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Helper operator for performing XLA-style broadcasts
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code lhsOutput()} output
  */
 @Operator(group = "xla")
-public final class BroadcastHelper<T extends TType> extends RawOp {
+public final class BroadcastHelper<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BroadcastHelper operation.
@@ -50,7 +50,7 @@ public final class BroadcastHelper<T extends TType> extends RawOp {
    * @return a new instance of BroadcastHelper
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> BroadcastHelper<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> broadcastDims) {
+  public static <T extends Tensor, U extends Tensor & TNumber> BroadcastHelper<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> broadcastDims) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaBroadcastHelper", scope.makeOpName("BroadcastHelper"));
     opBuilder.addInput(lhs.asOutput());
     opBuilder.addInput(rhs.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java
index 21a978fc7a8..7eb6a9ede78 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Operator that connects the output of an XLA computation to other consumer graph nodes.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code outputs()} output
  */
 @Operator(group = "xla")
-public final class ClusterOutput<T extends TType> extends RawOp implements Operand<T> {
+public final class ClusterOutput<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ClusterOutput operation.
@@ -43,7 +43,7 @@ public final class ClusterOutput<T extends TType> extends RawOp implements Opera
    * @return a new instance of ClusterOutput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> ClusterOutput<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> ClusterOutput<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaClusterOutput", scope.makeOpName("ClusterOutput"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java
index 7727cf1e9ac..0f478d65e81 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA ConvGeneralDilated operator, documented at
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Conv<T extends TType> extends RawOp implements Operand<T> {
+public final class Conv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Conv operation.
@@ -55,7 +55,7 @@ public final class Conv<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Conv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Conv<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> windowStrides, Operand<U> padding, Operand<U> lhsDilation, Operand<U> rhsDilation, Operand<U> featureGroupCount, String dimensionNumbers, String precisionConfig) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Conv<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> windowStrides, Operand<U> padding, Operand<U> lhsDilation, Operand<U> rhsDilation, Operand<U> featureGroupCount, String dimensionNumbers, String precisionConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaConv", scope.makeOpName("Conv"));
     opBuilder.addInput(lhs.asOutput());
     opBuilder.addInput(rhs.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java
index 0f3e1ef83df..c825c070a29 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA DotGeneral operator, documented at
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Dot<T extends TType> extends RawOp implements Operand<T> {
+public final class Dot<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dot operation.
@@ -49,7 +49,7 @@ public final class Dot<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Dot
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Dot<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, String dimensionNumbers, String precisionConfig) {
+  public static <T extends Tensor> Dot<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, String dimensionNumbers, String precisionConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaDot", scope.makeOpName("Dot"));
     opBuilder.addInput(lhs.asOutput());
     opBuilder.addInput(rhs.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java
index b6ecba31189..0f51e78708d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA DynamicSlice operator, documented at
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class DynamicSlice<T extends TType> extends RawOp implements Operand<T> {
+public final class DynamicSlice<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DynamicSlice operation.
@@ -58,7 +58,7 @@ public final class DynamicSlice<T extends TType> extends RawOp implements Operan
    * @return a new instance of DynamicSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> DynamicSlice<T> create(Scope scope, Operand<T> input, Operand<U> startIndices, Operand<U> sizeIndices) {
+  public static <T extends Tensor, U extends Tensor & TNumber> DynamicSlice<T> create(Scope scope, Operand<T> input, Operand<U> startIndices, Operand<U> sizeIndices) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaDynamicSlice", scope.makeOpName("DynamicSlice"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(startIndices.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java
index b974b64196e..7784b7eccb3 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA DynamicUpdateSlice operator, documented at
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class DynamicUpdateSlice<T extends TType> extends RawOp implements Operand<T> {
+public final class DynamicUpdateSlice<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DynamicUpdateSlice operation.
@@ -57,7 +57,7 @@ public final class DynamicUpdateSlice<T extends TType> extends RawOp implements
    * @return a new instance of DynamicUpdateSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> DynamicUpdateSlice<T> create(Scope scope, Operand<T> input, Operand<T> update, Operand<U> indices) {
+  public static <T extends Tensor, U extends Tensor & TNumber> DynamicUpdateSlice<T> create(Scope scope, Operand<T> input, Operand<T> update, Operand<U> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaDynamicUpdateSlice", scope.makeOpName("DynamicUpdateSlice"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(update.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java
index f5bf706641a..b94c88fea8a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * An op which supports basic einsum op with 2 inputs and 1 output.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "xla")
-public final class Einsum<T extends TType> extends RawOp implements Operand<T> {
+public final class Einsum<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Einsum operation.
@@ -48,7 +48,7 @@ public final class Einsum<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Einsum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Einsum<T> create(Scope scope, Operand<T> a, Operand<T> b, String equation) {
+  public static <T extends Tensor> Einsum<T> create(Scope scope, Operand<T> a, Operand<T> b, String equation) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaEinsum", scope.makeOpName("Einsum"));
     opBuilder.addInput(a.asOutput());
     opBuilder.addInput(b.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java
index d5b3298b395..4a2fcc9d6a8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Gather operator documented at
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Gather<T extends TType> extends RawOp implements Operand<T> {
+public final class Gather<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Gather operation.
@@ -50,7 +50,7 @@ public final class Gather<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Gather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Gather<T> create(Scope scope, Operand<T> operand, Operand<U> startIndices, Operand<U> sliceSizes, String dimensionNumbers, Boolean indicesAreSorted) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Gather<T> create(Scope scope, Operand<T> operand, Operand<U> startIndices, Operand<U> sliceSizes, String dimensionNumbers, Boolean indicesAreSorted) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaGather", scope.makeOpName("Gather"));
     opBuilder.addInput(operand.asOutput());
     opBuilder.addInput(startIndices.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java
index 9fd5e4c774d..731e2d4c73a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Sort operator, documented at
@@ -40,7 +40,7 @@
  * @param <U> data type for {@code sortedValues()} output
  */
 @Operator(group = "xla")
-public final class KeyValueSort<T extends TNumber, U extends TType> extends RawOp {
+public final class KeyValueSort<T extends Tensor & TNumber, U extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new KeyValueSort operation.
@@ -51,7 +51,7 @@ public final class KeyValueSort<T extends TNumber, U extends TType> extends RawO
    * @return a new instance of KeyValueSort
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TNumber, U extends TType> KeyValueSort<T, U> create(Scope scope, Operand<T> keys, Operand<U> values) {
+  public static <T extends Tensor & TNumber, U extends Tensor> KeyValueSort<T, U> create(Scope scope, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaKeyValueSort", scope.makeOpName("KeyValueSort"));
     opBuilder.addInput(keys.asOutput());
     opBuilder.addInput(values.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java
index eafaf001168..17dbca55b10 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Pad operator, documented at
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Pad<T extends TType> extends RawOp implements Operand<T> {
+public final class Pad<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Pad operation.
@@ -51,7 +51,7 @@ public final class Pad<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Pad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType, U extends TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<T> paddingValue, Operand<U> paddingLow, Operand<U> paddingHigh, Operand<U> paddingInterior) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<T> paddingValue, Operand<U> paddingLow, Operand<U> paddingHigh, Operand<U> paddingInterior) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaPad", scope.makeOpName("Pad"));
     opBuilder.addInput(input.asOutput());
     opBuilder.addInput(paddingValue.asOutput());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java
index 03274eb84e6..8a439f56dcc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java
@@ -22,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Receives the named tensor from another XLA computation. Wraps the XLA Recv
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator(group = "xla")
-public final class Recv<T extends TType> extends RawOp implements Operand<T> {
+public final class Recv<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Recv operation.
@@ -50,7 +50,7 @@ public final class Recv<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Recv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Recv<T> create(Scope scope, DataType<T> dtype, String tensorName, Shape shape) {
+  public static <T extends Tensor> Recv<T> create(Scope scope, DataType<T> dtype, String tensorName, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaRecv", scope.makeOpName("Recv"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java
index abbecd3e54b..5f060e363b0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of a batch of self-adjoint matrices
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code w()} output
  */
 @Operator(group = "xla")
-public final class SelfAdjointEig<T extends TType> extends RawOp {
+public final class SelfAdjointEig<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SelfAdjointEig operation.
@@ -56,7 +56,7 @@ public final class SelfAdjointEig<T extends TType> extends RawOp {
    * @return a new instance of SelfAdjointEig
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> SelfAdjointEig<T> create(Scope scope, Operand<T> a, Boolean lower, Long maxIter, Float epsilon) {
+  public static <T extends Tensor> SelfAdjointEig<T> create(Scope scope, Operand<T> a, Boolean lower, Long maxIter, Float epsilon) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSelfAdjointEig", scope.makeOpName("SelfAdjointEig"));
     opBuilder.addInput(a.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java
index 3e060842de3..64effb04c09 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java
@@ -20,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Sends the named tensor to another XLA computation. Wraps the XLA Send operator
@@ -44,7 +44,7 @@ public final class Send extends RawOp {
    * @return a new instance of Send
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Send create(Scope scope, Operand<T> tensor, String tensorName) {
+  public static <T extends Tensor> Send create(Scope scope, Operand<T> tensor, String tensorName) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSend", scope.makeOpName("Send"));
     opBuilder.addInput(tensor.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java
index d8d879183d2..a88479fab0d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * An op which shards the input based on the given sharding attribute.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Sharding<T extends TType> extends RawOp implements Operand<T> {
+public final class Sharding<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sharding operation.
@@ -43,7 +43,7 @@ public final class Sharding<T extends TType> extends RawOp implements Operand<T>
    * @return a new instance of Sharding
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sharding<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Sharding<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSharding", scope.makeOpName("Sharding"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java
index abafbd5e286..b3bf7be404e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Sort operator, documented at
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Sort<T extends TType> extends RawOp implements Operand<T> {
+public final class Sort<T extends Tensor> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sort operation.
@@ -48,7 +48,7 @@ public final class Sort<T extends TType> extends RawOp implements Operand<T> {
    * @return a new instance of Sort
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Sort<T> create(Scope scope, Operand<T> input) {
+  public static <T extends Tensor> Sort<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSort", scope.makeOpName("Sort"));
     opBuilder.addInput(input.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java
index e3571702151..ff212b541ef 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of a batch of self-adjoint matrices
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "xla")
-public final class Svd<T extends TType> extends RawOp {
+public final class Svd<T extends Tensor> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Svd operation.
@@ -54,7 +54,7 @@ public final class Svd<T extends TType> extends RawOp {
    * @return a new instance of Svd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends TType> Svd<T> create(Scope scope, Operand<T> a, Long maxIter, Float epsilon, String precisionConfig) {
+  public static <T extends Tensor> Svd<T> create(Scope scope, Operand<T> a, Long maxIter, Float epsilon, String precisionConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSvd", scope.makeOpName("Svd"));
     opBuilder.addInput(a.asOutput());
     opBuilder = scope.applyControlDependencies(opBuilder);
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java
index 96da6bc5ff4..71a9bc45bcf 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java
@@ -17,7 +17,6 @@
 
 import org.bytedeco.javacpp.Pointer;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.types.family.TType;
 
 /**
  * Base class for {@link Operation} implementations.
@@ -37,7 +36,7 @@ public Output<?>[] outputList(int idx, int length) {
   }
 
   @Override
-  public <T extends TType> Output<T> output(int idx) {
+  public <T extends Tensor> Output<T> output(int idx) {
     return new Output<>(this, idx);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
index 70edafa391a..974a04f3333 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
@@ -17,10 +17,9 @@
 
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.types.family.TType;
 
 /** Represents a type of elements in a {@link Tensor} */
-public final class DataType<T extends TType> {
+public final class DataType<T extends Tensor> {
 
   @FunctionalInterface
   public interface TensorInstantiator<T> {
@@ -43,7 +42,7 @@ public interface TensorInstantiator<T> {
    * @param byteSize size of an element of this type, in bytes, -1 if unknown
    * @param tensorMapper method for instantiating tensor from a native reference
    */
-  public static <T extends TType> DataType<T> create(String name, int value, int byteSize, TensorInstantiator<T> instantiator) {
+  public static <T extends Tensor> DataType<T> create(String name, int value, int byteSize, TensorInstantiator<T> instantiator) {
     return new DataType<>(name, value, byteSize, instantiator);
   }
 
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 070fc55cb0f..78228d1a5ec 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
@@ -39,7 +39,7 @@
  * tf.concat(split, tf.constant(0));
  * }</pre>
  */
-public interface Operand<T extends TType> extends Op {
+public interface Operand<T extends Tensor> extends Op {
 
   /**
    * Returns the symbolic handle of the tensor.
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java
index 1cc175da161..dd7903e07a6 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java
@@ -15,8 +15,6 @@
 
 package org.tensorflow;
 
-import org.tensorflow.types.family.TType;
-
 /**
  * Performs computation on Tensors.
  *
@@ -70,7 +68,7 @@ public interface Operation {
    * @param <T> The expected element type of the tensors produced by this output.
    * @param idx The index of the output among the outputs produced by this operation.
    */
-  <T extends TType> Output<T> output(int idx);
+  <T extends Tensor> Output<T> output(int idx);
 
   /**
    * Returns the size of the given inputs list of Tensors for this operation.
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 c6499377ded..944ed507ee1 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
@@ -18,7 +18,6 @@
 import java.util.Objects;
 import org.bytedeco.javacpp.Pointer;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.types.family.TType;
 
 /**
  * A symbolic handle to a tensor produced by an {@link Operation}.
@@ -29,7 +28,7 @@
  * <p>By implementing the {@link Operand} interface, instances of this class also act as operands to
  * {@link org.tensorflow.op.Op Op} instances.
  */
-public final class Output<T extends TType> implements Operand<T> {
+public final class Output<T extends Tensor> implements Operand<T> {
 
   /** Returns the index into the outputs of the Operation. */
   public int index() {
@@ -56,7 +55,7 @@ public DataType<T> dataType() {
    *     {@code U}.
    */
   @SuppressWarnings("unchecked")
-  public <U extends TType> Output<U> expect(DataType<U> dt) {
+  public <U extends Tensor> Output<U> expect(DataType<U> dt) {
     if (!dt.equals(this.dataType())) {
       throw new IllegalArgumentException(
           "Cannot cast from output of " + this.dataType() + " to output of " + dt);
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 16b93ba0590..c74492dd231 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
@@ -15,16 +15,12 @@
 
 package org.tensorflow;
 
-import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorByteSize;
-
 import java.util.function.Consumer;
-import org.bytedeco.javacpp.PointerScope;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.types.family.TType;
 
 /**
  * A statically typed multi-dimensional array whose elements are of a type described by T.
@@ -41,7 +37,7 @@
  * }
  * }</pre>
  */
-public interface Tensor<T extends TType> extends AutoCloseable {
+public interface Tensor<T> extends NdArray<T>, AutoCloseable {
 
   /**
    * Allocates a tensor of a given datatype and shape.
@@ -65,7 +61,7 @@ public interface Tensor<T extends TType> extends AutoCloseable {
    * @return an allocated but uninitialized tensor
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape) {
+  static <T extends Tensor> T of(DataType<T> dtype, Shape shape) {
     return of(dtype, shape, shape.size() * dtype.byteSize());
   }
 
@@ -88,7 +84,7 @@ static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape) {
    *                                  store the tensor data
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, long size) {
+  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, long size) {
     return Tensors.allocate(dtype, shape, size);
   }
 
@@ -116,7 +112,7 @@ static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, long size
    * @return an allocated and initialized tensor
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, Consumer<T> dataInitializer) {
+  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, Consumer<T> dataInitializer) {
     return of(dtype, shape, shape.size() * dtype.byteSize(), dataInitializer);
   }
 
@@ -140,7 +136,7 @@ static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, Consumer<
    *                                  store the tensor data
    * @throws IllegalStateException if tensor failed to be allocated
    */
-  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, long size, Consumer<T> tensorInit) {
+  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, long size, Consumer<T> tensorInit) {
     T tensor = of(dtype, shape, size);
     try {
       tensorInit.accept(tensor);
@@ -164,7 +160,7 @@ static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, long size
    * @throws IllegalArgumentException if {@code rawData} is not large enough to contain the tensor data
    * @throws IllegalStateException if tensor failed to be allocated with the given parameters
    */
-  static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, ByteDataBuffer rawData) {
+  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, ByteDataBuffer rawData) {
     T tensor = of(dtype, shape, rawData.size());
     rawData.copyTo(TensorBuffers.toBytes(tensor.nativeHandle()), rawData.size());
     return tensor;
@@ -179,7 +175,7 @@ static <T extends TType & Tensor> T of(DataType<T> dtype, Shape shape, ByteDataB
    *     {@code U}.
    */
   @SuppressWarnings("unchecked")
-  default <U extends TType & Tensor> U expect(DataType<U> dt) {
+  default <U extends Tensor> U expect(DataType<U> dt) {
     if (!dt.equals(dataType())) {
       throw new IllegalArgumentException(
           "Cannot cast from tensor of " + dataType() + " to tensor of " + dt);
@@ -199,7 +195,7 @@ default <U extends TType & Tensor> U expect(DataType<U> dt) {
   void close();
 
   /** Returns the {@link DataType} of elements stored in the Tensor. */
-  DataType<T> dataType();
+  DataType<?> dataType();
 
   /** Returns the size, in bytes, of the tensor data. */
   long numBytes();
@@ -243,10 +239,12 @@ default <U extends TType & Tensor> U expect(DataType<U> dt) {
    * @return the tensor data mapped to an n-dimensional space
    * @throws IllegalStateException if the tensor has been closed
    * @see NdArray
+   * @deprecated since tensor implements {@code NdArray}
    */
-  default T data() {
+  @Deprecated
+  default Tensor<T> data() {
     nativeHandle(); // make sure native handle is still valid
-    return (T) this;
+    return this;
   }
 
   /**
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
index 4ac2e92f714..b04a0f297b9 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
@@ -11,7 +11,7 @@
 
 final class Tensors {
 
-  static <T extends TType> T allocate(DataType<T> dataType, Shape shape, long size) {
+  static <T extends Tensor> T allocate(DataType<T> dataType, Shape shape, long size) {
     // Minimum requirements for datatypes of variable length cannot be verified in a relevant way so
     // we only validate them for fixed length datatypes
     if (!dataType.isVariableLength() && shape.size() * dataType.byteSize() > size) {
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java
new file mode 100644
index 00000000000..09318072a7f
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java
@@ -0,0 +1,96 @@
+package org.tensorflow.internal.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.impl.dense.BooleanDenseNdArray;
+import org.tensorflow.tensor.BooleanTensor;
+
+public class BooleanTensorImpl extends BooleanDenseNdArray implements BooleanTensor {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<?> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public BooleanTensor setBoolean(boolean value, long... coordinates) {
+    return (BooleanTensor)super.setBoolean(value, coordinates);
+  }
+
+  @Override
+  public BooleanTensor setObject(Boolean value, long... coordinates) {
+    return (BooleanTensor)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public BooleanTensor set(NdArray<Boolean> src, long... coordinates) {
+    return (BooleanTensor)super.set(src, coordinates);
+  }
+
+  @Override
+  public BooleanTensor copyTo(NdArray<Boolean> dst) {
+    return (BooleanTensor)super.copyTo(dst);
+  }
+
+  @Override
+  public BooleanTensor read(DataBuffer<Boolean> dst) {
+    return (BooleanTensor)super.read(dst);
+  }
+
+  @Override
+  public BooleanTensor read(BooleanDataBuffer dst) {
+    return (BooleanTensor)super.read(dst);
+  }
+
+  @Override
+  public BooleanTensor write(DataBuffer<Boolean> src) {
+    return (BooleanTensor)super.write(src);
+  }
+
+  @Override
+  public BooleanTensor write(BooleanDataBuffer src) {
+    return (BooleanTensor)super.write(src);
+  }
+
+  public BooleanTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, BooleanDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java
new file mode 100644
index 00000000000..7f4f4742ff6
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java
@@ -0,0 +1,95 @@
+package org.tensorflow.internal.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.impl.dense.ByteDenseNdArray;
+import org.tensorflow.tensor.ByteTensor;
+
+public class ByteTensorImpl extends ByteDenseNdArray implements ByteTensor {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<?> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public ByteTensor setByte(byte value, long... coordinates) {
+    return (ByteTensor)super.setByte(value, coordinates);
+  }
+
+  @Override
+  public ByteTensor setObject(Byte value, long... coordinates) {
+    return (ByteTensor)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public ByteTensor set(NdArray<Byte> src, long... coordinates) {
+    return (ByteTensor)super.set(src, coordinates);
+  }
+
+  @Override
+  public ByteTensor copyTo(NdArray<Byte> dst) {
+    return (ByteTensor)super.copyTo(dst);
+  }
+
+  @Override
+  public ByteTensor read(DataBuffer<Byte> dst) {
+    return (ByteTensor)super.read(dst);
+  }
+
+  @Override
+  public ByteTensor read(ByteDataBuffer dst) {
+    return (ByteTensor)super.read(dst);
+  }
+
+  @Override
+  public ByteTensor write(DataBuffer<Byte> src) {
+    return (ByteTensor)super.write(src);
+  }
+
+  @Override
+  public ByteTensor write(ByteDataBuffer src) {
+    return (ByteTensor)super.write(src);
+  }
+
+  public ByteTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, ByteDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java
new file mode 100644
index 00000000000..f4da880c976
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java
@@ -0,0 +1,96 @@
+package org.tensorflow.internal.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
+import org.tensorflow.ndarray.impl.dense.DoubleDenseNdArray;
+import org.tensorflow.tensor.DoubleTensor;
+
+public class DoubleTensorImpl extends DoubleDenseNdArray implements DoubleTensor {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<?> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public DoubleTensor setDouble(double value, long... coordinates) {
+    return (DoubleTensor)super.setDouble(value, coordinates);
+  }
+
+  @Override
+  public DoubleTensor setObject(Double value, long... coordinates) {
+    return (DoubleTensor)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public DoubleTensor set(NdArray<Double> src, long... coordinates) {
+    return (DoubleTensor)super.set(src, coordinates);
+  }
+
+  @Override
+  public DoubleTensor copyTo(NdArray<Double> dst) {
+    return (DoubleTensor)super.copyTo(dst);
+  }
+
+  @Override
+  public DoubleTensor read(DataBuffer<Double> dst) {
+    return (DoubleTensor)super.read(dst);
+  }
+
+  @Override
+  public DoubleTensor read(DoubleDataBuffer dst) {
+    return (DoubleTensor)super.read(dst);
+  }
+
+  @Override
+  public DoubleTensor write(DataBuffer<Double> src) {
+    return (DoubleTensor)super.write(src);
+  }
+
+  @Override
+  public DoubleTensor write(DoubleDataBuffer src) {
+    return (DoubleTensor)super.write(src);
+  }
+
+  public DoubleTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, DoubleDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java
new file mode 100644
index 00000000000..7aa4e824123
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java
@@ -0,0 +1,96 @@
+package org.tensorflow.internal.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.FloatDataBuffer;
+import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
+import org.tensorflow.tensor.FloatTensor;
+
+public class FloatTensorImpl extends FloatDenseNdArray implements FloatTensor {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<?> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public FloatTensor setFloat(float value, long... coordinates) {
+    return (FloatTensor)super.setFloat(value, coordinates);
+  }
+
+  @Override
+  public FloatTensor setObject(Float value, long... coordinates) {
+    return (FloatTensor)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public FloatTensor set(NdArray<Float> src, long... coordinates) {
+    return (FloatTensor)super.set(src, coordinates);
+  }
+
+  @Override
+  public FloatTensor copyTo(NdArray<Float> dst) {
+    return (FloatTensor)super.copyTo(dst);
+  }
+
+  @Override
+  public FloatTensor read(DataBuffer<Float> dst) {
+    return (FloatTensor)super.read(dst);
+  }
+
+  @Override
+  public FloatTensor read(FloatDataBuffer dst) {
+    return (FloatTensor)super.read(dst);
+  }
+
+  @Override
+  public FloatTensor write(DataBuffer<Float> src) {
+    return (FloatTensor)super.write(src);
+  }
+
+  @Override
+  public FloatTensor write(FloatDataBuffer src) {
+    return (FloatTensor)super.write(src);
+  }
+
+  public FloatTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, FloatDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java
new file mode 100644
index 00000000000..6febdda8c93
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java
@@ -0,0 +1,96 @@
+package org.tensorflow.internal.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.IntDataBuffer;
+import org.tensorflow.ndarray.impl.dense.IntDenseNdArray;
+import org.tensorflow.tensor.IntTensor;
+
+public class IntTensorImpl extends IntDenseNdArray implements IntTensor {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<?> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public IntTensor setInt(int value, long... coordinates) {
+    return (IntTensor)super.setInt(value, coordinates);
+  }
+
+  @Override
+  public IntTensor setObject(Integer value, long... coordinates) {
+    return (IntTensor)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public IntTensor set(NdArray<Integer> src, long... coordinates) {
+    return (IntTensor)super.set(src, coordinates);
+  }
+
+  @Override
+  public IntTensor copyTo(NdArray<Integer> dst) {
+    return (IntTensor)super.copyTo(dst);
+  }
+
+  @Override
+  public IntTensor read(DataBuffer<Integer> dst) {
+    return (IntTensor)super.read(dst);
+  }
+
+  @Override
+  public IntTensor read(IntDataBuffer dst) {
+    return (IntTensor)super.read(dst);
+  }
+
+  @Override
+  public IntTensor write(DataBuffer<Integer> src) {
+    return (IntTensor)super.write(src);
+  }
+
+  @Override
+  public IntTensor write(IntDataBuffer src) {
+    return (IntTensor)super.write(src);
+  }
+
+  public IntTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, IntDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java
new file mode 100644
index 00000000000..7dc68cf58ce
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java
@@ -0,0 +1,96 @@
+package org.tensorflow.internal.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.LongDataBuffer;
+import org.tensorflow.ndarray.impl.dense.LongDenseNdArray;
+import org.tensorflow.tensor.LongTensor;
+
+public class LongTensorImpl extends LongDenseNdArray implements LongTensor {
+
+  @Override
+  public TF_Tensor nativeHandle() {
+    return rawTensor.nativeHandle();
+  }
+
+  @Override
+  public DataType<?> dataType() {
+    return rawTensor.dataType();
+  }
+
+  @Override
+  public Shape shape() {
+    return rawTensor.shape();
+  }
+
+  @Override
+  public long numBytes() {
+    return rawTensor.numBytes();
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return rawTensor.rawData();
+  }
+
+  @Override
+  public void close() {
+    rawTensor.close();
+  }
+
+  @Override
+  public String toString() {
+    return rawTensor.toString();
+  }
+
+  @Override
+  public LongTensor setLong(long value, long... coordinates) {
+    return (LongTensor)super.setLong(value, coordinates);
+  }
+
+  @Override
+  public LongTensor setObject(Long value, long... coordinates) {
+    return (LongTensor)super.setObject(value, coordinates);
+  }
+
+  @Override
+  public LongTensor set(NdArray<Long> src, long... coordinates) {
+    return (LongTensor)super.set(src, coordinates);
+  }
+
+  @Override
+  public LongTensor copyTo(NdArray<Long> dst) {
+    return (LongTensor)super.copyTo(dst);
+  }
+
+  @Override
+  public LongTensor read(DataBuffer<Long> dst) {
+    return (LongTensor)super.read(dst);
+  }
+
+  @Override
+  public LongTensor read(LongDataBuffer dst) {
+    return (LongTensor)super.read(dst);
+  }
+
+  @Override
+  public LongTensor write(DataBuffer<Long> src) {
+    return (LongTensor)super.write(src);
+  }
+
+  @Override
+  public LongTensor write(LongDataBuffer src) {
+    return (LongTensor)super.write(src);
+  }
+
+  public LongTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, LongDataBuffer buffer) {
+    super(buffer, shape);
+    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  }
+
+  private final RawTensor rawTensor;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/RawTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/RawTensor.java
similarity index 75%
rename from tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/RawTensor.java
rename to tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/RawTensor.java
index 872546c8ae0..98b9720b727 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/RawTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/RawTensor.java
@@ -1,19 +1,16 @@
-package org.tensorflow.types;
+package org.tensorflow.internal.tensor;
 
 import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorByteSize;
 
 import org.bytedeco.javacpp.PointerScope;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.types.family.TType;
 
-class RawTensor<T extends TType> implements Tensor<T> {
+class RawTensor<T> {
 
-  @Override
   public TF_Tensor nativeHandle() {
     if (nativeHandle.isNull()) {
       throw new IllegalStateException("Tensor has been already released");
@@ -21,27 +18,22 @@ public TF_Tensor nativeHandle() {
     return nativeHandle;
   }
 
-  @Override
-  public DataType<T> dataType() {
+  public DataType<?> dataType() {
     return dtype;
   }
 
-  @Override
   public Shape shape() {
     return shape;
   }
 
-  @Override
   public long numBytes() {
     return TF_TensorByteSize(nativeHandle);
   }
 
-  @Override
   public ByteDataBuffer rawData() {
     return TensorBuffers.toBytes(nativeHandle, true);
   }
 
-  @Override
   public void close() {
     tensorScope.close();
   }
@@ -54,10 +46,10 @@ public String toString() {
 
   private final PointerScope tensorScope = new PointerScope();
   private final TF_Tensor nativeHandle;
-  private final DataType<T> dtype;
+  private final DataType<?> dtype;
   private final Shape shape;
 
-  RawTensor(TF_Tensor nativeHandle, DataType<T> dtype, Shape shape) {
+  RawTensor(TF_Tensor nativeHandle, DataType<?> dtype, Shape shape) {
     this.nativeHandle = nativeHandle;
     this.dtype = dtype;
     this.shape = shape;
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/StringTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/StringTensorImpl.java
similarity index 55%
rename from tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/StringTensor.java
rename to tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/StringTensorImpl.java
index ca03e589360..3ee3966a22f 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/StringTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/StringTensorImpl.java
@@ -1,8 +1,8 @@
-package org.tensorflow.types;
+package org.tensorflow.internal.tensor;
 
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.buffer.ByteSequenceTensorBuffer;
+import org.tensorflow.internal.tensor.buffer.ByteSequenceTensorBuffer;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.NdArrays;
@@ -11,33 +11,9 @@
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayout;
 import org.tensorflow.ndarray.impl.dense.DenseNdArray;
-import org.tensorflow.ndarray.index.Index;
-import org.tensorflow.types.family.TType;
+import org.tensorflow.tensor.StringTensor;
 
-public interface StringTensor<T extends StringTensor & TType> extends NdArray<String>, Tensor<T> {
-
-  /**
-   * @return the tensor data as a n-dimensional array of raw byte sequences.
-   */
-  NdArray<byte[]> asBytes();
-
-  @Override
-  T set(NdArray<String> src, long... coordinates);
-
-  @Override
-  T setObject(String value, long... coordinates);
-
-  @Override
-  T copyTo(NdArray<String> dst);
-
-  @Override
-  T read(DataBuffer<String> dst);
-
-  @Override
-  T write(DataBuffer<String> src);
-}
-
-class StringTensorImpl<T extends StringTensor & TType> extends DenseNdArray<String> implements StringTensor<T> {
+public class StringTensorImpl extends DenseNdArray<String> implements StringTensor {
 
   @Override
   public NdArray<byte[]> asBytes() {
@@ -50,7 +26,7 @@ public TF_Tensor nativeHandle() {
   }
 
   @Override
-  public DataType<T> dataType() {
+  public DataType<Tensor<String>> dataType() {
     return rawTensor.dataType();
   }
 
@@ -80,37 +56,37 @@ public String toString() {
   }
 
   @Override
-  public T setObject(String value, long... coordinates) {
-    return (T)super.setObject(value, coordinates);
+  public Tensor<String> setObject(String value, long... coordinates) {
+    return (Tensor<String>)super.setObject(value, coordinates);
   }
 
   @Override
-  public T set(NdArray<String> src, long... coordinates) {
-    return (T)super.set(src, coordinates);
+  public Tensor<String> set(NdArray<String> src, long... coordinates) {
+    return (Tensor<String>)super.set(src, coordinates);
   }
 
   @Override
-  public T copyTo(NdArray<String> dst) {
-    return (T)super.copyTo(dst);
+  public Tensor<String> copyTo(NdArray<String> dst) {
+    return (Tensor<String>)super.copyTo(dst);
   }
 
   @Override
-  public T read(DataBuffer<String> dst) {
-    return (T)super.read(dst);
+  public Tensor<String> read(DataBuffer<String> dst) {
+    return (Tensor<String>)super.read(dst);
   }
 
   @Override
-  public T write(DataBuffer<String> src) {
-    return (T)super.write(src);
+  public Tensor<String> write(DataBuffer<String> src) {
+    return (Tensor<String>)super.write(src);
   }
 
   protected ByteSequenceTensorBuffer rawBuffer() {
     return rawBuffer;
   }
 
-  StringTensorImpl(
+  public StringTensorImpl(
       TF_Tensor nativeHandle,
-      DataType<T> dataType,
+      DataType<?> dataType,
       Shape shape,
       DataLayout<DataBuffer<byte[]>, String> layout,
       ByteSequenceTensorBuffer buffer
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/ByteSequenceTensorBuffer.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/ByteSequenceTensorBuffer.java
similarity index 99%
rename from tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/ByteSequenceTensorBuffer.java
rename to tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/ByteSequenceTensorBuffer.java
index 3fc160bc432..be7701153e9 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/ByteSequenceTensorBuffer.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/ByteSequenceTensorBuffer.java
@@ -15,7 +15,7 @@
  *  =======================================================================
  */
 
-package org.tensorflow.internal.buffer;
+package org.tensorflow.internal.tensor.buffer;
 
 import java.nio.ReadOnlyBufferException;
 import java.util.function.Function;
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorBuffers.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/TensorBuffers.java
similarity index 99%
rename from tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorBuffers.java
rename to tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/TensorBuffers.java
index 415c5ca35ef..f06de6631c1 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorBuffers.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/TensorBuffers.java
@@ -15,7 +15,7 @@
  *  =======================================================================
  */
 
-package org.tensorflow.internal.buffer;
+package org.tensorflow.internal.tensor.buffer;
 
 import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorByteSize;
 import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorData;
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorRawDataBufferFactory.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/TensorRawDataBufferFactory.java
similarity index 98%
rename from tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorRawDataBufferFactory.java
rename to tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/TensorRawDataBufferFactory.java
index dbaf31f1dcc..3a35edf0485 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/buffer/TensorRawDataBufferFactory.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/buffer/TensorRawDataBufferFactory.java
@@ -15,7 +15,7 @@
  *  =======================================================================
  */
 
-package org.tensorflow.internal.buffer;
+package org.tensorflow.internal.tensor.buffer;
 
 import org.bytedeco.javacpp.Pointer;
 import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
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 c583bd8db0a..2fc69dd9188 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,18 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.Output;
 import org.tensorflow.Tensor;
-import org.tensorflow.op.RawOp;
-import org.tensorflow.op.Scope;
-import org.tensorflow.op.annotation.Endpoint;
-import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
-import org.tensorflow.ndarray.buffer.FloatDataBuffer;
-import org.tensorflow.ndarray.buffer.IntDataBuffer;
-import org.tensorflow.ndarray.buffer.LongDataBuffer;
 import org.tensorflow.ndarray.BooleanNdArray;
 import org.tensorflow.ndarray.ByteNdArray;
 import org.tensorflow.ndarray.DoubleNdArray;
@@ -41,7 +29,19 @@
 import org.tensorflow.ndarray.LongNdArray;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.NdArrays;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
+import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
+import org.tensorflow.ndarray.buffer.FloatDataBuffer;
+import org.tensorflow.ndarray.buffer.IntDataBuffer;
+import org.tensorflow.ndarray.buffer.LongDataBuffer;
+import org.tensorflow.op.RawOp;
+import org.tensorflow.op.Scope;
+import org.tensorflow.op.annotation.Endpoint;
+import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TFloat64;
@@ -66,7 +66,7 @@
  * }</pre>
  */
 @Operator
-public final class Constant<T extends TType> extends RawOp implements Operand<T> {
+public final class Constant<T extends Tensor> extends RawOp implements Operand<T> {
 
   /**
    * Creates a constant containing a single {@code int} element.
@@ -77,7 +77,7 @@ public final class Constant<T extends TType> extends RawOp implements Operand<T>
    */
   @Endpoint
   public static Constant<TInt32> scalarOf(Scope scope, int data) {
-    try (Tensor<TInt32> value = TInt32.scalarOf(data)) {
+    try (TInt32 value = TInt32.scalarOf(data)) {
       return create(scope, value);
     }
   }
@@ -92,7 +92,7 @@ public static Constant<TInt32> scalarOf(Scope scope, int data) {
    */
   @Endpoint
   public static Constant<TInt32> vectorOf(Scope scope, int[] data) {
-    try (Tensor<TInt32> value = TInt32.vectorOf(data)) {
+    try (TInt32 value = TInt32.vectorOf(data)) {
       return create(scope, value);
     }
   }
@@ -122,7 +122,7 @@ public static Constant<TInt32> arrayOf(Scope scope, int... data) {
    */
   @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][] data) {
-    try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt32 value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -138,7 +138,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][] data) {
    */
   @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][] data) {
-    try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt32 value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -154,7 +154,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][] data) {
    */
   @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][][] data) {
-    try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt32 value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -170,7 +170,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][][] data) {
    */
   @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][][][] data) {
-    try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt32 value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -186,7 +186,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][][][] data) {
    */
   @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, int[][][][][][] data) {
-    try (Tensor<TInt32> value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt32 value = TInt32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -201,7 +201,7 @@ public static Constant<TInt32> tensorOf(Scope scope, int[][][][][][] data) {
    */
   @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, IntNdArray data) {
-    try (Tensor<TInt32> value = TInt32.tensorOf(data)) {
+    try (TInt32 value = TInt32.tensorOf(data)) {
       return create(scope, value);
     }
   }
@@ -217,7 +217,7 @@ public static Constant<TInt32> tensorOf(Scope scope, IntNdArray data) {
    */
   @Endpoint
   public static Constant<TInt32> tensorOf(Scope scope, Shape shape, IntDataBuffer data) {
-    try (Tensor<TInt32> value = TInt32.tensorOf(shape, data)) {
+    try (TInt32 value = TInt32.tensorOf(shape, data)) {
       return create(scope, value);
     }
   }
@@ -231,7 +231,7 @@ public static Constant<TInt32> tensorOf(Scope scope, Shape shape, IntDataBuffer
    */
   @Endpoint
   public static Constant<TFloat32> scalarOf(Scope scope, float data) {
-    try (Tensor<TFloat32> value = TFloat32.scalarOf(data)) {
+    try (TFloat32 value = TFloat32.scalarOf(data)) {
       return create(scope, value);
     }
   }
@@ -246,7 +246,7 @@ public static Constant<TFloat32> scalarOf(Scope scope, float data) {
    */
   @Endpoint
   public static Constant<TFloat32> vectorOf(Scope scope, float[] data) {
-    try (Tensor<TFloat32> value = TFloat32.vectorOf(data)) {
+    try (TFloat32 value = TFloat32.vectorOf(data)) {
       return create(scope, value);
     }
   }
@@ -276,7 +276,7 @@ public static Constant<TFloat32> arrayOf(Scope scope, float... data) {
    */
   @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][] data) {
-    try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat32 value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -292,7 +292,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][] data) {
    */
   @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][] data) {
-    try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat32 value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -308,7 +308,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][] data) {
    */
   @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][][] data) {
-    try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat32 value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -324,7 +324,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][][] data) {
    */
   @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][] data) {
-    try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat32 value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -340,7 +340,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][] data) {
    */
   @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][][] data) {
-    try (Tensor<TFloat32> value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat32 value = TFloat32.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -355,7 +355,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, float[][][][][][] data) {
    */
   @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, FloatNdArray data) {
-    try (Tensor<TFloat32> value = TFloat32.tensorOf(data)) {
+    try (TFloat32 value = TFloat32.tensorOf(data)) {
       return create(scope, value);
     }
   }
@@ -371,7 +371,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, FloatNdArray data) {
    */
   @Endpoint
   public static Constant<TFloat32> tensorOf(Scope scope, Shape shape, FloatDataBuffer data) {
-    try (Tensor<TFloat32> value = TFloat32.tensorOf(shape, data)) {
+    try (TFloat32 value = TFloat32.tensorOf(shape, data)) {
       return create(scope, value);
     }
   }
@@ -385,7 +385,7 @@ public static Constant<TFloat32> tensorOf(Scope scope, Shape shape, FloatDataBuf
    */
   @Endpoint
   public static Constant<TFloat64> scalarOf(Scope scope, double data) {
-    try (Tensor<TFloat64> value = TFloat64.scalarOf(data)) {
+    try (TFloat64 value = TFloat64.scalarOf(data)) {
       return create(scope, value);
     }
   }
@@ -400,7 +400,7 @@ public static Constant<TFloat64> scalarOf(Scope scope, double data) {
    */
   @Endpoint
   public static Constant<TFloat64> vectorOf(Scope scope, double[] data) {
-    try (Tensor<TFloat64> value = TFloat64.vectorOf(data)) {
+    try (TFloat64 value = TFloat64.vectorOf(data)) {
       return create(scope, value);
     }
   }
@@ -430,7 +430,7 @@ public static Constant<TFloat64> arrayOf(Scope scope, double... data) {
    */
   @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][] data) {
-    try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat64 value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -446,7 +446,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][] data) {
    */
   @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][] data) {
-    try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat64 value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -462,7 +462,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][] data) {
    */
   @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][][] data) {
-    try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat64 value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -478,7 +478,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][][] data) {
    */
   @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][] data) {
-    try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat64 value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -494,7 +494,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][] data) {
    */
   @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][][] data) {
-    try (Tensor<TFloat64> value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
+    try (TFloat64 value = TFloat64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(
         data, t))) {
       return create(scope, value);
     }
@@ -509,7 +509,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, double[][][][][][] data)
    */
   @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, DoubleNdArray data) {
-    try (Tensor<TFloat64> value = TFloat64.tensorOf(data)) {
+    try (TFloat64 value = TFloat64.tensorOf(data)) {
       return create(scope, value);
     }
   }
@@ -525,7 +525,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, DoubleNdArray data) {
    */
   @Endpoint
   public static Constant<TFloat64> tensorOf(Scope scope, Shape shape, DoubleDataBuffer data) {
-    try (Tensor<TFloat64> value = TFloat64.tensorOf(shape, data)) {
+    try (TFloat64 value = TFloat64.tensorOf(shape, data)) {
       return create(scope, value);
     }
   }
@@ -539,7 +539,7 @@ public static Constant<TFloat64> tensorOf(Scope scope, Shape shape, DoubleDataBu
    */
   @Endpoint
   public static Constant<TInt64> scalarOf(Scope scope, long data) {
-    try (Tensor<TInt64> value = TInt64.scalarOf(data)) {
+    try (TInt64 value = TInt64.scalarOf(data)) {
       return create(scope, value);
     }
   }
@@ -554,7 +554,7 @@ public static Constant<TInt64> scalarOf(Scope scope, long data) {
    */
   @Endpoint
   public static Constant<TInt64> vectorOf(Scope scope, long[] data) {
-    try (Tensor<TInt64> value = TInt64.vectorOf(data)) {
+    try (TInt64 value = TInt64.vectorOf(data)) {
       return create(scope, value);
     }
   }
@@ -569,7 +569,7 @@ public static Constant<TInt64> vectorOf(Scope scope, long[] data) {
    */
   @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][] data) {
-    try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt64 value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -600,7 +600,7 @@ public static Constant<TInt64> arrayOf(Scope scope, long... data) {
    */
   @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][] data) {
-    try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt64 value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -616,7 +616,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][] data) {
    */
   @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][][] data) {
-    try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt64 value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -632,7 +632,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][][] data) {
    */
   @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][][][] data) {
-    try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt64 value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -648,7 +648,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][][][] data) {
    */
   @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, long[][][][][][] data) {
-    try (Tensor<TInt64> value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TInt64 value = TInt64.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -663,7 +663,7 @@ public static Constant<TInt64> tensorOf(Scope scope, long[][][][][][] data) {
    */
   @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, LongNdArray data) {
-    try (Tensor<TInt64> value = TInt64.tensorOf(data)) {
+    try (TInt64 value = TInt64.tensorOf(data)) {
       return create(scope, value);
     }
   }
@@ -679,7 +679,7 @@ public static Constant<TInt64> tensorOf(Scope scope, LongNdArray data) {
    */
   @Endpoint
   public static Constant<TInt64> tensorOf(Scope scope, Shape shape, LongDataBuffer data) {
-    try (Tensor<TInt64> value = TInt64.tensorOf(shape, data)) {
+    try (TInt64 value = TInt64.tensorOf(shape, data)) {
       return create(scope, value);
     }
   }
@@ -693,7 +693,7 @@ public static Constant<TInt64> tensorOf(Scope scope, Shape shape, LongDataBuffer
    */
   @Endpoint
   public static Constant<TBool> scalarOf(Scope scope, boolean data) {
-    try (Tensor<TBool> value = TBool.scalarOf(data)) {
+    try (TBool value = TBool.scalarOf(data)) {
       return create(scope, value);
     }
   }
@@ -708,7 +708,7 @@ public static Constant<TBool> scalarOf(Scope scope, boolean data) {
    */
   @Endpoint
   public static Constant<TBool> vectorOf(Scope scope, boolean[] data) {
-    try (Tensor<TBool> value = TBool.vectorOf(data)) {
+    try (TBool value = TBool.vectorOf(data)) {
       return create(scope, value);
     }
   }
@@ -738,7 +738,7 @@ public static Constant<TBool> arrayOf(Scope scope, boolean... data) {
    */
   @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][] data) {
-    try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TBool value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -754,7 +754,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][] data) {
    */
   @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][] data) {
-    try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TBool value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -770,7 +770,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][] data) {
    */
   @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][][] data) {
-    try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TBool value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -786,7 +786,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][][] data) {
    */
   @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][] data) {
-    try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TBool value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -802,7 +802,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][] data) {
    */
   @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][][] data) {
-    try (Tensor<TBool> value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
+    try (TBool value = TBool.tensorOf(StdArrays.shapeOf(data), t -> StdArrays.copyTo(data,
         t))) {
       return create(scope, value);
     }
@@ -817,7 +817,7 @@ public static Constant<TBool> tensorOf(Scope scope, boolean[][][][][][] data) {
    */
   @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, BooleanNdArray data) {
-    try (Tensor<TBool> value = TBool.tensorOf(data)) {
+    try (TBool value = TBool.tensorOf(data)) {
       return create(scope, value);
     }
   }
@@ -833,7 +833,7 @@ public static Constant<TBool> tensorOf(Scope scope, BooleanNdArray data) {
    */
   @Endpoint
   public static Constant<TBool> tensorOf(Scope scope, Shape shape, BooleanDataBuffer data) {
-    try (Tensor<TBool> value = TBool.tensorOf(shape, data)) {
+    try (TBool value = TBool.tensorOf(shape, data)) {
       return create(scope, value);
     }
   }
@@ -847,7 +847,7 @@ public static Constant<TBool> tensorOf(Scope scope, Shape shape, BooleanDataBuff
    */
   @Endpoint
   public static Constant<TUint8> scalarOf(Scope scope, byte data) {
-    try (Tensor<TUint8> value = TUint8.scalarOf(data)) {
+    try (TUint8 value = TUint8.scalarOf(data)) {
       return create(scope, value);
     }
   }
@@ -862,7 +862,7 @@ public static Constant<TUint8> scalarOf(Scope scope, byte data) {
    */
   @Endpoint
   public static Constant<TUint8> vectorOf(Scope scope, byte[] data) {
-    try (Tensor<TUint8> value = TUint8.vectorOf(data)) {
+    try (TUint8 value = TUint8.vectorOf(data)) {
       return create(scope, value);
     }
   }
@@ -892,7 +892,7 @@ public static Constant<TUint8> arrayOf(Scope scope, byte... data) {
    */
   @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][] data) {
-    try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
+    try (TUint8 value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
         d))) {
       return create(scope, value);
     }
@@ -908,7 +908,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][] data) {
    */
   @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][] data) {
-    try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
+    try (TUint8 value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
         d))) {
       return create(scope, value);
     }
@@ -924,7 +924,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][] data) {
    */
   @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][][] data) {
-    try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
+    try (TUint8 value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
         d))) {
       return create(scope, value);
     }
@@ -940,7 +940,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][][] data) {
    */
   @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][] data) {
-    try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
+    try (TUint8 value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
         d))) {
       return create(scope, value);
     }
@@ -956,7 +956,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][] data) {
    */
   @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][][] data) {
-    try (Tensor<TUint8> value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
+    try (TUint8 value = TUint8.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(data,
         d))) {
       return create(scope, value);
     }
@@ -971,7 +971,7 @@ public static Constant<TUint8> tensorOf(Scope scope, byte[][][][][][] data) {
    */
   @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, ByteNdArray data) {
-    try (Tensor<TUint8> value = TUint8.tensorOf(data)) {
+    try (TUint8 value = TUint8.tensorOf(data)) {
       return create(scope, value);
     }
   }
@@ -987,7 +987,7 @@ public static Constant<TUint8> tensorOf(Scope scope, ByteNdArray data) {
    */
   @Endpoint
   public static Constant<TUint8> tensorOf(Scope scope, Shape shape, ByteDataBuffer data) {
-    try (Tensor<TUint8> value = TUint8.tensorOf(shape, data)) {
+    try (TUint8 value = TUint8.tensorOf(shape, data)) {
       return create(scope, value);
     }
   }
@@ -1004,7 +1004,7 @@ public static Constant<TUint8> tensorOf(Scope scope, Shape shape, ByteDataBuffer
    *     buffer
    */
   @Endpoint
-  public static <T extends TType & Tensor> Constant<T> tensorOf(Scope scope, DataType<T> type, Shape shape,
+  public static <T extends Tensor & TType> Constant<T> tensorOf(Scope scope, DataType<T> type, Shape shape,
       ByteDataBuffer data) {
     try (T value = Tensor.of(type, shape, data)) {
       return create(scope, value);
@@ -1020,7 +1020,7 @@ public static <T extends TType & Tensor> Constant<T> tensorOf(Scope scope, DataT
    */
   @Endpoint
   public static Constant<TString> scalarOf(Scope scope, String data) {
-    try (Tensor<TString> value = TString.scalarOf(data)) {
+    try (TString value = TString.scalarOf(data)) {
       return create(scope, value);
     }
   }
@@ -1035,7 +1035,7 @@ public static Constant<TString> scalarOf(Scope scope, String data) {
    */
   @Endpoint
   public static Constant<TString> scalarOf(Scope scope, Charset charset, String data) {
-    try (Tensor<TString> value = TString.tensorOf(charset, NdArrays.scalarOfObject(data))) {
+    try (TString value = TString.tensorOf(charset, NdArrays.scalarOfObject(data))) {
       return create(scope, value);
     }
   }
@@ -1049,7 +1049,7 @@ public static Constant<TString> scalarOf(Scope scope, Charset charset, String da
    */
   public static Constant<TString> vectorOf(Scope scope, String[] data) {
     NdArray<String> src = NdArrays.vectorOfObjects(data);
-    try (Tensor<TString> value = TString.tensorOf(src)) {
+    try (TString value = TString.tensorOf(src)) {
       return create(scope, value);
     }
   }
@@ -1065,7 +1065,7 @@ public static Constant<TString> vectorOf(Scope scope, String[] data) {
    */
   @Endpoint
   public static Constant<TString> vectorOf(Scope scope, Charset charset, String[] data) {
-    try (Tensor<TString> value = TString.tensorOf(charset, NdArrays.vectorOfObjects(data))) {
+    try (TString value = TString.tensorOf(charset, NdArrays.vectorOfObjects(data))) {
       return Constant.create(scope, value);
     }
   }
@@ -1112,7 +1112,7 @@ public static Constant<TString> arrayOf(Scope scope, Charset charset, String...
   public static Constant<TString> tensorOf(Scope scope, String[][] data) {
     NdArray<String> src = NdArrays.ofObjects(String.class, StdArrays.shapeOf(data));
     StdArrays.copyTo(data, src);
-    try (Tensor<TString> value = TString.tensorOf(src)) {
+    try (TString value = TString.tensorOf(src)) {
       return create(scope, value);
     }
   }
@@ -1127,7 +1127,7 @@ public static Constant<TString> tensorOf(Scope scope, String[][] data) {
   public static Constant<TString> tensorOf(Scope scope, String[][][] data) {
     NdArray<String> src = NdArrays.ofObjects(String.class, StdArrays.shapeOf(data));
     StdArrays.copyTo(data, src);
-    try (Tensor<TString> value = TString.tensorOf(src)) {
+    try (TString value = TString.tensorOf(src)) {
       return create(scope, value);
     }
   }
@@ -1142,7 +1142,7 @@ public static Constant<TString> tensorOf(Scope scope, String[][][] data) {
   public static Constant<TString> tensorOf(Scope scope, String[][][][] data) {
     NdArray<String> src = NdArrays.ofObjects(String.class, StdArrays.shapeOf(data));
     StdArrays.copyTo(data, src);
-    try (Tensor<TString> value = TString.tensorOf(src)) {
+    try (TString value = TString.tensorOf(src)) {
       return create(scope, value);
     }
   }
@@ -1157,7 +1157,7 @@ public static Constant<TString> tensorOf(Scope scope, String[][][][] data) {
   public static Constant<TString> tensorOf(Scope scope, String[][][][][] data) {
     NdArray<String> src = NdArrays.ofObjects(String.class, StdArrays.shapeOf(data));
     StdArrays.copyTo(data, src);
-    try (Tensor<TString> value = TString.tensorOf(src)) {
+    try (TString value = TString.tensorOf(src)) {
       return create(scope, value);
     }
   }
@@ -1172,7 +1172,7 @@ public static Constant<TString> tensorOf(Scope scope, String[][][][][] data) {
   public static Constant<TString> tensorOf(Scope scope, String[][][][][][] data) {
     NdArray<String> src = NdArrays.ofObjects(String.class, StdArrays.shapeOf(data));
     StdArrays.copyTo(data, src);
-    try (Tensor<TString> value = TString.tensorOf(src)) {
+    try (TString value = TString.tensorOf(src)) {
       return create(scope, value);
     }
   }
@@ -1187,7 +1187,7 @@ public static Constant<TString> tensorOf(Scope scope, String[][][][][][] data) {
    */
   @Endpoint
   public static Constant<TString> tensorOf(Scope scope, NdArray<String> data) {
-    try (Tensor<TString> value = TString.tensorOf(data)) {
+    try (TString value = TString.tensorOf(data)) {
       return create(scope, value);
     }
   }
@@ -1203,7 +1203,7 @@ public static Constant<TString> tensorOf(Scope scope, NdArray<String> data) {
    */
   @Endpoint
   public static Constant<TString> tensorOf(Scope scope, Charset charset, NdArray<String> data) {
-    try (Tensor<TString> value = TString.tensorOf(charset, data)) {
+    try (TString value = TString.tensorOf(charset, data)) {
       return create(scope, value);
     }
   }
@@ -1220,7 +1220,7 @@ public static Constant<TString> tensorOf(Scope scope, Charset charset, NdArray<S
    */
   @Endpoint
   public static Constant<TString> tensorOf(Scope scope, Shape shape, DataBuffer<String> data) {
-    try (Tensor<TString> value = TString.tensorOf(shape, data)) {
+    try (TString value = TString.tensorOf(shape, data)) {
       return create(scope, value);
     }
   }
@@ -1238,7 +1238,7 @@ public static Constant<TString> tensorOf(Scope scope, Shape shape, DataBuffer<St
   @Endpoint
   public static Constant<TString> tensorOf(Scope scope, Charset charset, Shape shape,
       DataBuffer<String> data) {
-    try (Tensor<TString> value = TString.tensorOf(charset, shape, data)) {
+    try (TString value = TString.tensorOf(charset, shape, data)) {
       return create(scope, value);
     }
   }
@@ -1264,7 +1264,7 @@ public static Constant<TInt64> tensorOf(Scope scope, Shape shape) {
    * @return a constant of the same data type as `tensor`
    */
   @Endpoint
-  public static <T extends TType> Constant<T> create(Scope scope, Tensor<T> tensor) {
+  public static <T extends Tensor & TType> Constant<T> create(Scope scope, T tensor) {
     return new Constant<>(
         scope
             .env()
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 2827276c32c..f5192697628 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
@@ -22,12 +22,11 @@
 import org.tensorflow.Graph;
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
-import org.tensorflow.op.Op;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Adds operations to compute the partial derivatives of sum of {@code y}s w.r.t {@code x}s,
@@ -158,7 +157,7 @@ public List<Output<?>> dy() {
    * @param index The index of the output among the gradients added by this operation
    */
   @SuppressWarnings("unchecked")
-  public <T extends TType> Output<T> dy(int index) {
+  public <T extends Tensor> Output<T> dy(int index) {
     return (Output<T>) dy.get(index);
   }
 
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 f9ce837fe60..123f7eb826b 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
@@ -17,10 +17,10 @@
 
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-import org.tensorflow.types.family.TType;
 
 /**
  * Container class for core methods which add or perform several operations
@@ -45,7 +45,7 @@ private Helpers() {}
      * @return a new instance of Variable
      */
     @Endpoint(name = "variable")
-    public static <T extends TType> Variable<T> createVariableWithInit(Scope scope, Operand<T> init, Variable.Options... options) {
+    public static <T extends Tensor> 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);
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java
index 613cb729341..14bc0604ce6 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java
@@ -18,6 +18,7 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
@@ -31,7 +32,6 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An operator providing methods on org.tensorflow.op.core.Shape tensors and 1d operands that
@@ -67,7 +67,7 @@ public abstract class Shapes {
    * @return the reshaped operand
    */
   @Endpoint(name = "flatten")
-  public static <T extends TType> Operand<T> flatten(Scope scope, Operand<T> operand) {
+  public static <T extends Tensor> Operand<T> flatten(Scope scope, Operand<T> operand) {
     return flatten(scope, operand, TInt32.DTYPE);
   }
 
@@ -82,7 +82,7 @@ public static <T extends TType> Operand<T> flatten(Scope scope, Operand<T> opera
    * @return the reshaped operand
    */
   @Endpoint(name = "flatten")
-  public static <T extends TType, U extends TNumber> Operand<T> flatten(
+  public static <T extends Tensor, U extends Tensor & TNumber> Operand<T> flatten(
       Scope scope, Operand<T> operand, DataType<U> dType) {
     Operand<U> flatShape = flatten(scope, Shape.create(scope, operand, dType), dType);
     return Reshape.create(scope, operand, flatShape);
@@ -110,7 +110,7 @@ public static Operand<TInt32> flatten(Scope scope, Shape<TInt32> shape) {
    * @return the flattened shape
    */
   @Endpoint(name = "flatten")
-  public static <U extends TNumber> Operand<U> flatten(
+  public static <U extends Tensor & TNumber> Operand<U> flatten(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return ExpandDims.create(
         scope,
@@ -140,7 +140,7 @@ public static Operand<TInt32> size(Scope scope, Shape<TInt32> shape) {
    * @return the size
    */
   @Endpoint(name = "size")
-  public static <U extends TNumber> Operand<U> size(
+  public static <U extends Tensor & TNumber> Operand<U> size(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     Slice<U> dims =
         Slice.create(
@@ -178,7 +178,7 @@ public static Operand<TInt32> size(Scope scope, Shape<TInt32> shape, Operand<TIn
    * @return the size of the specified dimension
    */
   @Endpoint(name = "size")
-  public static <U extends TNumber> Operand<U> size(
+  public static <U extends Tensor & TNumber> Operand<U> size(
       Scope scope, Shape<U> shape, Operand<U> dim, DataType<U> dType) {
     return Slice.create(
         scope,
@@ -199,7 +199,7 @@ public static <U extends TNumber> Operand<U> size(
    * @return the size of the specified dimension
    */
   @Endpoint(name = "size")
-  public static <T extends TType> Operand<TInt32> size(
+  public static <T extends Tensor> Operand<TInt32> size(
       Scope scope, Operand<T> input, Operand<TInt32> dim) {
     return size(scope, input, dim, TInt32.DTYPE);
   }
@@ -215,7 +215,7 @@ public static <T extends TType> Operand<TInt32> size(
    * @return the size of the specified dimension
    */
   @Endpoint(name = "size")
-  public static <T extends TType, U extends TNumber> Operand<U> size(
+  public static <T extends Tensor, U extends Tensor & TNumber> Operand<U> size(
       Scope scope, Operand<T> input, Operand<U> dim, DataType<U> dType) {
     return size(scope, Shape.create(scope, input, dType), dim, dType);
   }
@@ -242,7 +242,7 @@ public static Operand<TInt32> numDimensions(Scope scope, Shape<TInt32> shape) {
    * @return the number of dimensions
    */
   @Endpoint(name = "numDimensions")
-  public static <U extends TNumber> Operand<U> numDimensions(
+  public static <U extends Tensor & TNumber> Operand<U> numDimensions(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return Size.create(scope, shape, dType);
   }
@@ -257,7 +257,7 @@ public static <U extends TNumber> Operand<U> numDimensions(
    * @return the reshaped operand
    */
   @Endpoint(name = "reduceDims")
-  public static <T extends TType> Operand<T> reduceDims(
+  public static <T extends Tensor> Operand<T> reduceDims(
       Scope scope, Operand<T> operand, Operand<TInt32> axis) {
     return reduceDims(scope, operand, axis, TInt32.DTYPE);
   }
@@ -274,7 +274,7 @@ public static <T extends TType> Operand<T> reduceDims(
    * @return the reshaped operand
    */
   @Endpoint(name = "reduceDims")
-  public static <T extends TType, U extends TNumber> Operand<T> reduceDims(
+  public static <T extends Tensor, U extends Tensor & TNumber> Operand<T> reduceDims(
       Scope scope, Operand<T> operand, Operand<U> axis, DataType<U> dType) {
     Shape<U> newShape = Shape.create(scope, operand, dType);
     return Reshape.create(scope, operand, reduceDims(scope, newShape, axis, dType));
@@ -304,7 +304,7 @@ public static Operand<TInt32> reduceDims(Scope scope, Shape<TInt32> shape, Opera
    * @return the reduced shape
    */
   @Endpoint(name = "reduceDims")
-  public static <U extends TNumber> Operand<U> reduceDims(
+  public static <U extends Tensor & TNumber> Operand<U> reduceDims(
       Scope scope, Shape<U> shape, Operand<U> axis, DataType<U> dType) {
     Size<U> rank = Size.create(scope, shape, dType);
     axis = FloorMod.create(scope, axis, rank);
@@ -356,7 +356,7 @@ public static Operand<TInt32> squeeze(Scope scope, Shape<TInt32> shape) {
    * @return the squeezed shape
    */
   @Endpoint(name = "squeeze")
-  public static <U extends TNumber> Operand<U> squeeze(
+  public static <U extends Tensor & TNumber> Operand<U> squeeze(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     Operand<TBool> mask =
         NotEqual.create(scope, shape, Cast.create(scope, OnesLike.create(scope, shape), dType));
@@ -386,7 +386,7 @@ public static Operand<TInt32> head(Scope scope, Shape<TInt32> shape) {
    * @return a 1-dimensional Operand containing the Shape's first dimension
    */
   @Endpoint(name = "head")
-  public static <U extends TNumber> Operand<U> head(
+  public static <U extends Tensor & TNumber> Operand<U> head(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return take(scope, shape, Cast.create(scope, Constant.scalarOf(scope, 1), dType), dType);
   }
@@ -419,7 +419,7 @@ public static Operand<TInt32> take(Scope scope, Shape<TInt32> shape, Operand<TIn
    *     shape
    */
   @Endpoint(name = "take")
-  public static <U extends TNumber> Operand<U> take(
+  public static <U extends Tensor & TNumber> Operand<U> take(
       Scope scope, Shape<U> shape, Operand<U> n, DataType<U> dType) {
     return Slice.create(
         scope,
@@ -454,7 +454,7 @@ public static Operand<TInt32> tail(Scope scope, Shape<TInt32> shape) {
    *     Shape
    */
   @Endpoint(name = "tail")
-  public static <U extends TNumber> Operand<U> tail(
+  public static <U extends Tensor & TNumber> Operand<U> tail(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return takeLast(scope, shape, Cast.create(scope, Constant.scalarOf(scope, 1), dType), dType);
   }
@@ -470,7 +470,7 @@ public static <U extends TNumber> Operand<U> tail(
    *     shape
    */
   @Endpoint(name = "takeLast")
-  public static <U extends TNumber> Operand<TInt32> takeLast(
+  public static <U extends Tensor & TNumber> Operand<TInt32> takeLast(
       Scope scope, Shape<TInt32> shape, Operand<TInt32> n) {
     return takeLast(scope, shape, n, TInt32.DTYPE);
   }
@@ -488,7 +488,7 @@ public static <U extends TNumber> Operand<TInt32> takeLast(
    *     shape
    */
   @Endpoint(name = "takeLast")
-  public static <U extends TNumber> Operand<U> takeLast(
+  public static <U extends Tensor & TNumber> Operand<U> takeLast(
       Scope scope, Shape<U> shape, Operand<U> n, DataType<U> dType) {
 
     Size<U> rank = Size.create(scope, shape, dType);
@@ -548,7 +548,7 @@ public static Operand<TInt64> prepend(Scope scope, Shape<TInt64> shape, long fir
    *     representing the shape
    */
   @Endpoint(name = "prepend")
-  public static <T extends TNumber> Operand<T> prepend(
+  public static <T extends Tensor & TNumber> Operand<T> prepend(
       Scope scope, Operand<T> shape, Operand<T> shapeToPrepend) {
 
     return Concat.create(scope, Arrays.asList(shapeToPrepend, shape), Constant.scalarOf(scope, 0));
@@ -600,7 +600,7 @@ public static Operand<TInt64> append(Scope scope, Shape<TInt64> shape, long last
    *     to append
    */
   @Endpoint(name = "append")
-  public static <T extends TNumber> Operand<T> append(
+  public static <T extends Tensor & TNumber> Operand<T> append(
       Scope scope, Operand<T> shape, Operand<T> shapeToAppend) {
     return Concat.create(scope, Arrays.asList(shape, shapeToAppend), Constant.scalarOf(scope, 0));
   }
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 4aad417b117..389be13e59d 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
@@ -18,6 +18,7 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.Output;
+import org.tensorflow.Tensor;
 import org.tensorflow.op.Op;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -25,7 +26,6 @@
 import org.tensorflow.op.dtypes.Cast;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
-import org.tensorflow.types.family.TType;
 
 /**
  * An operator creating a constant initialized with zeros of the shape given by `dims`.
@@ -38,7 +38,7 @@
  * @param <T> constant type
  */
 @Operator
-public final class Zeros<T extends TType> implements Op, Operand<T> {
+public final class Zeros<T extends Tensor> implements Op, Operand<T> {
 
   /**
    * Creates a zeroed tensor given its type and shape.
@@ -51,7 +51,7 @@ public final class Zeros<T extends TType> implements Op, Operand<T> {
    */
   @Endpoint
   @SuppressWarnings("unchecked")
-  public static <T extends TType, U extends TNumber> Zeros<T> create(Scope scope, Operand<U> dims, DataType<T> type) {
+  public static <T extends Tensor, U extends Tensor & TNumber> Zeros<T> create(Scope scope, Operand<U> dims, DataType<T> type) {
     Scope zerosScope = scope.withSubScope("Zeros");
     Operand<T> zero;
     if (type == TString.DTYPE) {
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java
new file mode 100644
index 00000000000..ac270e7ad0e
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java
@@ -0,0 +1,40 @@
+package org.tensorflow.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.BooleanNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.impl.dense.BooleanDenseNdArray;
+
+public interface BooleanTensor extends BooleanNdArray, Tensor<Boolean> {
+
+  @Override
+  BooleanTensor setBoolean(boolean value, long... coordinates);
+
+  @Override
+  BooleanTensor set(NdArray<Boolean> src, long... coordinates);
+
+  @Override
+  BooleanTensor setObject(Boolean value, long... coordinates);
+
+  @Override
+  BooleanTensor copyTo(NdArray<Boolean> dst);
+
+  @Override
+  BooleanTensor read(DataBuffer<Boolean> dst);
+
+  @Override
+  BooleanTensor read(BooleanDataBuffer dst);
+
+  @Override
+  BooleanTensor write(DataBuffer<Boolean> src);
+
+  @Override
+  BooleanTensor write(BooleanDataBuffer src);
+}
+
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java
new file mode 100644
index 00000000000..ba18867765b
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java
@@ -0,0 +1,39 @@
+package org.tensorflow.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.ByteNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.impl.dense.ByteDenseNdArray;
+
+public interface ByteTensor extends ByteNdArray, Tensor<Byte> {
+
+  @Override
+  ByteTensor setByte(byte value, long... coordinates);
+
+  @Override
+  ByteTensor set(NdArray<Byte> src, long... coordinates);
+
+  @Override
+  ByteTensor setObject(Byte value, long... coordinates);
+
+  @Override
+  ByteTensor copyTo(NdArray<Byte> dst);
+
+  @Override
+  ByteTensor read(DataBuffer<Byte> dst);
+
+  @Override
+  ByteTensor read(ByteDataBuffer dst);
+
+  @Override
+  ByteTensor write(DataBuffer<Byte> src);
+
+  @Override
+  ByteTensor write(ByteDataBuffer src);
+}
+
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java
new file mode 100644
index 00000000000..4f8b1b5b0c2
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java
@@ -0,0 +1,40 @@
+package org.tensorflow.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.DoubleNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
+import org.tensorflow.ndarray.impl.dense.DoubleDenseNdArray;
+
+public interface DoubleTensor extends DoubleNdArray, Tensor<Double> {
+
+  @Override
+  DoubleTensor setDouble(double value, long... coordinates);
+
+  @Override
+  DoubleTensor set(NdArray<Double> src, long... coordinates);
+
+  @Override
+  DoubleTensor setObject(Double value, long... coordinates);
+
+  @Override
+  DoubleTensor copyTo(NdArray<Double> dst);
+
+  @Override
+  DoubleTensor read(DataBuffer<Double> dst);
+
+  @Override
+  DoubleTensor read(DoubleDataBuffer dst);
+
+  @Override
+  DoubleTensor write(DataBuffer<Double> src);
+
+  @Override
+  DoubleTensor write(DoubleDataBuffer src);
+}
+
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java
new file mode 100644
index 00000000000..c06e9c5f0d9
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java
@@ -0,0 +1,40 @@
+package org.tensorflow.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.FloatNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.FloatDataBuffer;
+import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
+
+public interface FloatTensor extends FloatNdArray, Tensor<Float> {
+
+  @Override
+  FloatTensor setFloat(float value, long... coordinates);
+
+  @Override
+  FloatTensor set(NdArray<Float> src, long... coordinates);
+
+  @Override
+  FloatTensor setObject(Float value, long... coordinates);
+
+  @Override
+  FloatTensor copyTo(NdArray<Float> dst);
+
+  @Override
+  FloatTensor read(DataBuffer<Float> dst);
+
+  @Override
+  FloatTensor read(FloatDataBuffer dst);
+
+  @Override
+  FloatTensor write(DataBuffer<Float> src);
+
+  @Override
+  FloatTensor write(FloatDataBuffer src);
+}
+
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java
new file mode 100644
index 00000000000..52d3930a844
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java
@@ -0,0 +1,40 @@
+package org.tensorflow.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.IntNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.IntDataBuffer;
+import org.tensorflow.ndarray.impl.dense.IntDenseNdArray;
+
+public interface IntTensor extends IntNdArray, Tensor<Integer> {
+
+  @Override
+  IntTensor setInt(int value, long... coordinates);
+
+  @Override
+  IntTensor set(NdArray<Integer> src, long... coordinates);
+
+  @Override
+  IntTensor setObject(Integer value, long... coordinates);
+
+  @Override
+  IntTensor copyTo(NdArray<Integer> dst);
+
+  @Override
+  IntTensor read(DataBuffer<Integer> dst);
+
+  @Override
+  IntTensor read(IntDataBuffer dst);
+
+  @Override
+  IntTensor write(DataBuffer<Integer> src);
+
+  @Override
+  IntTensor write(IntDataBuffer src);
+}
+
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java
new file mode 100644
index 00000000000..1a29bb278d6
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java
@@ -0,0 +1,40 @@
+package org.tensorflow.tensor;
+
+import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.LongNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.ndarray.buffer.LongDataBuffer;
+import org.tensorflow.ndarray.impl.dense.LongDenseNdArray;
+
+public interface LongTensor extends LongNdArray, Tensor<Long> {
+
+  @Override
+  LongTensor setLong(long value, long... coordinates);
+
+  @Override
+  LongTensor set(NdArray<Long> src, long... coordinates);
+
+  @Override
+  LongTensor setObject(Long value, long... coordinates);
+
+  @Override
+  LongTensor copyTo(NdArray<Long> dst);
+
+  @Override
+  LongTensor read(DataBuffer<Long> dst);
+
+  @Override
+  LongTensor read(LongDataBuffer dst);
+
+  @Override
+  LongTensor write(DataBuffer<Long> src);
+
+  @Override
+  LongTensor write(LongDataBuffer src);
+}
+
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java
new file mode 100644
index 00000000000..78a9c2d43a0
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java
@@ -0,0 +1,29 @@
+package org.tensorflow.tensor;
+
+import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+
+public interface StringTensor extends Tensor<String> {
+
+  /**
+   * @return the tensor data as a n-dimensional array of raw byte sequences.
+   */
+  NdArray<byte[]> asBytes();
+
+  @Override
+  Tensor<String> set(NdArray<String> src, long... coordinates);
+
+  @Override
+  Tensor<String> setObject(String value, long... coordinates);
+
+  @Override
+  Tensor<String> copyTo(NdArray<String> dst);
+
+  @Override
+  Tensor<String> read(DataBuffer<String> dst);
+
+  @Override
+  Tensor<String> write(DataBuffer<String> src);
+}
+
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java
deleted file mode 100644
index 627062a990f..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/BooleanTensor.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.tensorflow.types;
-
-import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.BooleanNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.impl.dense.BooleanDenseNdArray;
-import org.tensorflow.ndarray.index.Index;
-import org.tensorflow.types.family.TType;
-
-public interface BooleanTensor<T extends BooleanTensor & TType> extends BooleanNdArray, Tensor<T> {
-
-  @Override
-  T setBoolean(boolean value, long... coordinates);
-
-  @Override
-  T set(NdArray<Boolean> src, long... coordinates);
-
-  @Override
-  T setObject(Boolean value, long... coordinates);
-
-  @Override
-  T copyTo(NdArray<Boolean> dst);
-
-  @Override
-  T read(DataBuffer<Boolean> dst);
-
-  @Override
-  T read(BooleanDataBuffer dst);
-
-  @Override
-  T write(DataBuffer<Boolean> src);
-
-  @Override
-  T write(BooleanDataBuffer src);
-}
-
-class BooleanTensorImpl<T extends BooleanTensor & TType> extends BooleanDenseNdArray implements BooleanTensor<T> {
-
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
-  }
-
-  @Override
-  public DataType<T> dataType() {
-    return rawTensor.dataType();
-  }
-
-  @Override
-  public Shape shape() {
-    return rawTensor.shape();
-  }
-
-  @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
-  }
-
-  @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
-  }
-
-  @Override
-  public void close() {
-    rawTensor.close();
-  }
-
-  @Override
-  public String toString() {
-    return rawTensor.toString();
-  }
-
-  @Override
-  public T setBoolean(boolean value, long... coordinates) {
-    return (T)super.setBoolean(value, coordinates);
-  }
-
-  @Override
-  public T setObject(Boolean value, long... coordinates) {
-    return (T)super.setObject(value, coordinates);
-  }
-
-  @Override
-  public T set(NdArray<Boolean> src, long... coordinates) {
-    return (T)super.set(src, coordinates);
-  }
-
-  @Override
-  public T copyTo(NdArray<Boolean> dst) {
-    return (T)super.copyTo(dst);
-  }
-
-  @Override
-  public T read(DataBuffer<Boolean> dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T read(BooleanDataBuffer dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T write(DataBuffer<Boolean> src) {
-    return (T)super.write(src);
-  }
-
-  @Override
-  public T write(BooleanDataBuffer src) {
-    return (T)super.write(src);
-  }
-
-  BooleanTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, BooleanDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
-  }
-
-  private final RawTensor rawTensor;
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java
deleted file mode 100644
index 48451e3781c..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/ByteTensor.java
+++ /dev/null
@@ -1,125 +0,0 @@
-package org.tensorflow.types;
-
-import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.ByteNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.impl.dense.ByteDenseNdArray;
-import org.tensorflow.ndarray.index.Index;
-import org.tensorflow.types.family.TType;
-
-public interface ByteTensor<T extends ByteTensor & TType> extends ByteNdArray, Tensor<T> {
-
-  @Override
-  T setByte(byte value, long... coordinates);
-
-  @Override
-  T set(NdArray<Byte> src, long... coordinates);
-
-  @Override
-  T setObject(Byte value, long... coordinates);
-
-  @Override
-  T copyTo(NdArray<Byte> dst);
-
-  @Override
-  T read(DataBuffer<Byte> dst);
-
-  @Override
-  T read(ByteDataBuffer dst);
-
-  @Override
-  T write(DataBuffer<Byte> src);
-
-  @Override
-  T write(ByteDataBuffer src);
-}
-
-class ByteTensorImpl<T extends ByteTensor & TType> extends ByteDenseNdArray implements ByteTensor<T> {
-
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
-  }
-
-  @Override
-  public DataType<T> dataType() {
-    return rawTensor.dataType();
-  }
-
-  @Override
-  public Shape shape() {
-    return rawTensor.shape();
-  }
-
-  @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
-  }
-
-  @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
-  }
-
-  @Override
-  public void close() {
-    rawTensor.close();
-  }
-
-  @Override
-  public String toString() {
-    return rawTensor.toString();
-  }
-
-  @Override
-  public T setByte(byte value, long... coordinates) {
-    return (T)super.setByte(value, coordinates);
-  }
-
-  @Override
-  public T setObject(Byte value, long... coordinates) {
-    return (T)super.setObject(value, coordinates);
-  }
-
-  @Override
-  public T set(NdArray<Byte> src, long... coordinates) {
-    return (T)super.set(src, coordinates);
-  }
-
-  @Override
-  public T copyTo(NdArray<Byte> dst) {
-    return (T)super.copyTo(dst);
-  }
-
-  @Override
-  public T read(DataBuffer<Byte> dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T read(ByteDataBuffer dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T write(DataBuffer<Byte> src) {
-    return (T)super.write(src);
-  }
-
-  @Override
-  public T write(ByteDataBuffer src) {
-    return (T)super.write(src);
-  }
-
-  ByteTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, ByteDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
-  }
-
-  private final RawTensor rawTensor;
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java
deleted file mode 100644
index 83fb0fa1c0d..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/DoubleTensor.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.tensorflow.types;
-
-import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.DoubleNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
-import org.tensorflow.ndarray.impl.dense.DoubleDenseNdArray;
-import org.tensorflow.ndarray.index.Index;
-import org.tensorflow.types.family.TType;
-
-public interface DoubleTensor<T extends DoubleTensor & TType> extends DoubleNdArray, Tensor<T> {
-
-  @Override
-  T setDouble(double value, long... coordinates);
-
-  @Override
-  T set(NdArray<Double> src, long... coordinates);
-
-  @Override
-  T setObject(Double value, long... coordinates);
-
-  @Override
-  T copyTo(NdArray<Double> dst);
-
-  @Override
-  T read(DataBuffer<Double> dst);
-
-  @Override
-  T read(DoubleDataBuffer dst);
-
-  @Override
-  T write(DataBuffer<Double> src);
-
-  @Override
-  T write(DoubleDataBuffer src);
-}
-
-class DoubleTensorImpl<T extends DoubleTensor & TType> extends DoubleDenseNdArray implements DoubleTensor<T> {
-
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
-  }
-
-  @Override
-  public DataType<T> dataType() {
-    return rawTensor.dataType();
-  }
-
-  @Override
-  public Shape shape() {
-    return rawTensor.shape();
-  }
-
-  @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
-  }
-
-  @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
-  }
-
-  @Override
-  public void close() {
-    rawTensor.close();
-  }
-
-  @Override
-  public String toString() {
-    return rawTensor.toString();
-  }
-
-  @Override
-  public T setDouble(double value, long... coordinates) {
-    return (T)super.setDouble(value, coordinates);
-  }
-
-  @Override
-  public T setObject(Double value, long... coordinates) {
-    return (T)super.setObject(value, coordinates);
-  }
-
-  @Override
-  public T set(NdArray<Double> src, long... coordinates) {
-    return (T)super.set(src, coordinates);
-  }
-
-  @Override
-  public T copyTo(NdArray<Double> dst) {
-    return (T)super.copyTo(dst);
-  }
-
-  @Override
-  public T read(DataBuffer<Double> dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T read(DoubleDataBuffer dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T write(DataBuffer<Double> src) {
-    return (T)super.write(src);
-  }
-
-  @Override
-  public T write(DoubleDataBuffer src) {
-    return (T)super.write(src);
-  }
-
-  DoubleTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, DoubleDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
-  }
-
-  private final RawTensor rawTensor;
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java
deleted file mode 100644
index f819d073a4d..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/FloatTensor.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.tensorflow.types;
-
-import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.FloatNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.buffer.FloatDataBuffer;
-import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
-import org.tensorflow.ndarray.index.Index;
-import org.tensorflow.types.family.TType;
-
-public interface FloatTensor<T extends FloatTensor & TType> extends FloatNdArray, Tensor<T> {
-
-  @Override
-  T setFloat(float value, long... coordinates);
-
-  @Override
-  T set(NdArray<Float> src, long... coordinates);
-
-  @Override
-  T setObject(Float value, long... coordinates);
-
-  @Override
-  T copyTo(NdArray<Float> dst);
-
-  @Override
-  T read(DataBuffer<Float> dst);
-
-  @Override
-  T read(FloatDataBuffer dst);
-
-  @Override
-  T write(DataBuffer<Float> src);
-
-  @Override
-  T write(FloatDataBuffer src);
-}
-
-class FloatTensorImpl<T extends FloatTensor & TType> extends FloatDenseNdArray implements FloatTensor<T> {
-
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
-  }
-
-  @Override
-  public DataType<T> dataType() {
-    return rawTensor.dataType();
-  }
-
-  @Override
-  public Shape shape() {
-    return rawTensor.shape();
-  }
-
-  @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
-  }
-
-  @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
-  }
-
-  @Override
-  public void close() {
-    rawTensor.close();
-  }
-
-  @Override
-  public String toString() {
-    return rawTensor.toString();
-  }
-
-  @Override
-  public T setFloat(float value, long... coordinates) {
-    return (T)super.setFloat(value, coordinates);
-  }
-
-  @Override
-  public T setObject(Float value, long... coordinates) {
-    return (T)super.setObject(value, coordinates);
-  }
-
-  @Override
-  public T set(NdArray<Float> src, long... coordinates) {
-    return (T)super.set(src, coordinates);
-  }
-
-  @Override
-  public T copyTo(NdArray<Float> dst) {
-    return (T)super.copyTo(dst);
-  }
-
-  @Override
-  public T read(DataBuffer<Float> dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T read(FloatDataBuffer dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T write(DataBuffer<Float> src) {
-    return (T)super.write(src);
-  }
-
-  @Override
-  public T write(FloatDataBuffer src) {
-    return (T)super.write(src);
-  }
-
-  FloatTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, FloatDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
-  }
-
-  private final RawTensor rawTensor;
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java
deleted file mode 100644
index 041232e83d8..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/IntTensor.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.tensorflow.types;
-
-import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.IntNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.buffer.IntDataBuffer;
-import org.tensorflow.ndarray.impl.dense.IntDenseNdArray;
-import org.tensorflow.ndarray.index.Index;
-import org.tensorflow.types.family.TType;
-
-public interface IntTensor<T extends IntTensor & TType> extends IntNdArray, Tensor<T> {
-
-  @Override
-  T setInt(int value, long... coordinates);
-
-  @Override
-  T set(NdArray<Integer> src, long... coordinates);
-
-  @Override
-  T setObject(Integer value, long... coordinates);
-
-  @Override
-  T copyTo(NdArray<Integer> dst);
-
-  @Override
-  T read(DataBuffer<Integer> dst);
-
-  @Override
-  T read(IntDataBuffer dst);
-
-  @Override
-  T write(DataBuffer<Integer> src);
-
-  @Override
-  T write(IntDataBuffer src);
-}
-
-class IntTensorImpl<T extends IntTensor & TType> extends IntDenseNdArray implements IntTensor<T> {
-
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
-  }
-
-  @Override
-  public DataType<T> dataType() {
-    return rawTensor.dataType();
-  }
-
-  @Override
-  public Shape shape() {
-    return rawTensor.shape();
-  }
-
-  @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
-  }
-
-  @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
-  }
-
-  @Override
-  public void close() {
-    rawTensor.close();
-  }
-
-  @Override
-  public String toString() {
-    return rawTensor.toString();
-  }
-
-  @Override
-  public T setInt(int value, long... coordinates) {
-    return (T)super.setInt(value, coordinates);
-  }
-
-  @Override
-  public T setObject(Integer value, long... coordinates) {
-    return (T)super.setObject(value, coordinates);
-  }
-
-  @Override
-  public T set(NdArray<Integer> src, long... coordinates) {
-    return (T)super.set(src, coordinates);
-  }
-
-  @Override
-  public T copyTo(NdArray<Integer> dst) {
-    return (T)super.copyTo(dst);
-  }
-
-  @Override
-  public T read(DataBuffer<Integer> dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T read(IntDataBuffer dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T write(DataBuffer<Integer> src) {
-    return (T)super.write(src);
-  }
-
-  @Override
-  public T write(IntDataBuffer src) {
-    return (T)super.write(src);
-  }
-
-  IntTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, IntDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
-  }
-
-  private final RawTensor rawTensor;
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java
deleted file mode 100644
index b8965888f34..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/LongTensor.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.tensorflow.types;
-
-import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.LongNdArray;
-import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.buffer.LongDataBuffer;
-import org.tensorflow.ndarray.impl.dense.LongDenseNdArray;
-import org.tensorflow.ndarray.index.Index;
-import org.tensorflow.types.family.TType;
-
-public interface LongTensor<T extends LongTensor & TType> extends LongNdArray, Tensor<T> {
-
-  @Override
-  T setLong(long value, long... coordinates);
-
-  @Override
-  T set(NdArray<Long> src, long... coordinates);
-
-  @Override
-  T setObject(Long value, long... coordinates);
-
-  @Override
-  T copyTo(NdArray<Long> dst);
-
-  @Override
-  T read(DataBuffer<Long> dst);
-
-  @Override
-  T read(LongDataBuffer dst);
-
-  @Override
-  T write(DataBuffer<Long> src);
-
-  @Override
-  T write(LongDataBuffer src);
-}
-
-class LongTensorImpl<T extends LongTensor & TType> extends LongDenseNdArray implements LongTensor<T> {
-
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
-  }
-
-  @Override
-  public DataType<T> dataType() {
-    return rawTensor.dataType();
-  }
-
-  @Override
-  public Shape shape() {
-    return rawTensor.shape();
-  }
-
-  @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
-  }
-
-  @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
-  }
-
-  @Override
-  public void close() {
-    rawTensor.close();
-  }
-
-  @Override
-  public String toString() {
-    return rawTensor.toString();
-  }
-
-  @Override
-  public T setLong(long value, long... coordinates) {
-    return (T)super.setLong(value, coordinates);
-  }
-
-  @Override
-  public T setObject(Long value, long... coordinates) {
-    return (T)super.setObject(value, coordinates);
-  }
-
-  @Override
-  public T set(NdArray<Long> src, long... coordinates) {
-    return (T)super.set(src, coordinates);
-  }
-
-  @Override
-  public T copyTo(NdArray<Long> dst) {
-    return (T)super.copyTo(dst);
-  }
-
-  @Override
-  public T read(DataBuffer<Long> dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T read(LongDataBuffer dst) {
-    return (T)super.read(dst);
-  }
-
-  @Override
-  public T write(DataBuffer<Long> src) {
-    return (T)super.write(src);
-  }
-
-  @Override
-  public T write(LongDataBuffer src) {
-    return (T)super.write(src);
-  }
-
-  LongTensorImpl(TF_Tensor nativeHandle, DataType<T> dataType, Shape shape, LongDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
-  }
-
-  private final RawTensor rawTensor;
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
index cc3aeba4282..6c772fa44cf 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
@@ -21,14 +21,16 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.FloatTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.FloatDataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayouts;
-import org.tensorflow.types.family.TFloat;
+import org.tensorflow.tensor.FloatTensor;
+import org.tensorflow.types.family.TFloating;
 
 /**
  * Brain 16-bit float tensor type.
@@ -45,7 +47,7 @@
  * <p>Note that some CPUs support the bfloat16 format natively, which can result in faster computation
  * compared to {@link TFloat16} when GPUs are not used.
  */
-public interface TBfloat16 extends FloatTensor<TBfloat16>, TFloat {
+public interface TBfloat16 extends FloatTensor, TFloating {
 
   /** Type metadata */
   DataType<TBfloat16> DTYPE = DataType.create("BFLOAT16", 14, 2, TBfloat16Impl::new);
@@ -122,7 +124,7 @@ static TBfloat16 tensorOf(Shape shape, Consumer<TBfloat16> tensorInit) {
 /**
  * Hidden implementation of a {@code TBfloat16}
  */
-class TBfloat16Impl extends FloatTensorImpl<TBfloat16> implements TBfloat16 {
+class TBfloat16Impl extends FloatTensorImpl implements TBfloat16 {
 
   TBfloat16Impl(TF_Tensor nativeTensorHandle, Shape shape) {
     super(nativeTensorHandle, DTYPE, shape, mapMemory(nativeTensorHandle));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
index 7566e0a5099..9d2180eb0a8 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
@@ -21,13 +21,15 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.BooleanTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayouts;
+import org.tensorflow.tensor.BooleanTensor;
 import org.tensorflow.types.family.TType;
 
 /**
@@ -38,7 +40,7 @@
  * {@link DataLayouts#BOOL BOOL} layout, which may impact I/O
  * performances.
  */
-public interface TBool extends BooleanTensor<TBool>, TType {
+public interface TBool extends BooleanTensor, TType {
 
   /** Type metadata */
   DataType<TBool> DTYPE = DataType.create("BOOL", 10, 1, TBoolImpl::new);
@@ -115,7 +117,7 @@ static TBool tensorOf(Shape shape, Consumer<TBool> tensorInit) {
 /**
  * Hidden implementation of a {@code TBool}
  */
-class TBoolImpl extends BooleanTensorImpl<TBool> implements TBool {
+class TBoolImpl extends BooleanTensorImpl implements TBool {
 
   TBoolImpl(TF_Tensor nativeTensor, Shape shape) {
     super(nativeTensor, DTYPE, shape, TensorBuffers.toBooleans(nativeTensor));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
index 114bf6d902b..fa4673830b3 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
@@ -21,14 +21,16 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.FloatTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.FloatDataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayouts;
-import org.tensorflow.types.family.TFloat;
+import org.tensorflow.tensor.FloatTensor;
+import org.tensorflow.types.family.TFloating;
 
 /**
  * IEEE-754 half-precision 16-bit float tensor type.
@@ -42,7 +44,7 @@
  * CPUs do not support this format natively. For CPU computation on 16-bit floats, the {@link TBfloat16}
  * tensor type might be a better option.
  */
-public interface TFloat16 extends FloatTensor<TFloat16>, TFloat {
+public interface TFloat16 extends FloatTensor, TFloating {
 
   /** Type metadata */
   DataType<TFloat16> DTYPE = DataType.create("FLOAT16", 19, 2, TFloat16Impl::new);
@@ -119,7 +121,7 @@ static TFloat16 tensorOf(Shape shape, Consumer<TFloat16> tensorInit) {
 /**
  * Hidden implementation of a {@code TFloat16}
  */
-class TFloat16Impl extends FloatTensorImpl<TFloat16> implements TFloat16 {
+class TFloat16Impl extends FloatTensorImpl implements TFloat16 {
 
   TFloat16Impl(TF_Tensor nativeTensor, Shape shape) {
     super(nativeTensor, DTYPE, shape, mapMemory(nativeTensor));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
index a4309a7db74..1b48af903ce 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
@@ -21,18 +21,20 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.FloatTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.FloatDataBuffer;
-import org.tensorflow.types.family.TFloat;
+import org.tensorflow.tensor.FloatTensor;
+import org.tensorflow.types.family.TFloating;
 
 /**
  * IEEE-754 single-precision 32-bit float tensor type.
  */
-public interface TFloat32 extends FloatTensor<TFloat32>, TFloat {
+public interface TFloat32 extends FloatTensor, TFloating {
 
   /** Type metadata */
   DataType<TFloat32> DTYPE = DataType.create("FLOAT", 1, 4, TFloat32Impl::new);
@@ -109,7 +111,7 @@ static TFloat32 tensorOf(Shape shape, Consumer<TFloat32> tensorInit) {
 /**
  * Hidden implementation of a {@code TFloat32}
  */
-class TFloat32Impl extends FloatTensorImpl<TFloat32> implements TFloat32 {
+class TFloat32Impl extends FloatTensorImpl implements TFloat32 {
 
   TFloat32Impl(TF_Tensor nativeTensor, Shape shape) {
     super(nativeTensor, DTYPE, shape, TensorBuffers.toFloats(nativeTensor));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
index f909aa6f5ee..ae92bb37b12 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
@@ -21,18 +21,20 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.DoubleTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
-import org.tensorflow.types.family.TFloat;
+import org.tensorflow.tensor.DoubleTensor;
+import org.tensorflow.types.family.TFloating;
 
 /**
  * IEEE-754 double-precision 64-bit float tensor type.
  */
-public interface TFloat64 extends DoubleTensor<TFloat64>, TFloat {
+public interface TFloat64 extends DoubleTensor, TFloating {
 
   /** Type metadata */
   DataType<TFloat64> DTYPE = DataType.create("DOUBLE", 2, 8, TFloat64Impl::new);
@@ -109,7 +111,7 @@ static TFloat64 tensorOf(Shape shape, Consumer<TFloat64> tensorInit) {
 /**
  * Hidden implementation of a {@code TFloat64}
  */
-class TFloat64Impl extends DoubleTensorImpl<TFloat64> implements TFloat64 {
+class TFloat64Impl extends DoubleTensorImpl implements TFloat64 {
 
   TFloat64Impl(TF_Tensor nativeTensor, Shape shape) {
     super(nativeTensor, DTYPE, shape, TensorBuffers.toDoubles(nativeTensor));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
index 312fb082eda..40fd74aff90 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
@@ -20,18 +20,20 @@
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.IntTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.IntDataBuffer;
+import org.tensorflow.tensor.IntTensor;
 import org.tensorflow.types.family.TNumber;
 
 /**
  * 32-bit signed integer tensor type.
  */
-public interface TInt32 extends IntTensor<TInt32>, TNumber {
+public interface TInt32 extends IntTensor, TNumber {
 
   /** Type metadata */
   DataType<TInt32> DTYPE = DataType.create("INT32", 3, 4, TInt32Impl::new);
@@ -108,7 +110,7 @@ static TInt32 tensorOf(Shape shape, Consumer<TInt32> tensorInit) {
 /**
  * Hidden implementation of a {@code TInt32}
  */
-class TInt32Impl extends IntTensorImpl<TInt32> implements TInt32 {
+class TInt32Impl extends IntTensorImpl implements TInt32 {
 
   TInt32Impl(TF_Tensor nativeTensor, Shape shape) {
     super(nativeTensor, DTYPE, shape, TensorBuffers.toInts(nativeTensor));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
index b90cd26264f..249ea94035d 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
@@ -21,18 +21,20 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.LongTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.LongDataBuffer;
+import org.tensorflow.tensor.LongTensor;
 import org.tensorflow.types.family.TNumber;
 
 /**
  * 64-bit signed integer tensor type.
  */
-public interface TInt64 extends LongTensor<TInt64>, TNumber {
+public interface TInt64 extends LongTensor, TNumber {
 
   /** Type metadata */
   DataType<TInt64> DTYPE = DataType.create("INT64", 9, 8, TInt64Impl::new);
@@ -109,7 +111,7 @@ static TInt64 tensorOf(Shape shape, Consumer<TInt64> tensorInit) {
 /**
  * Hidden implementation of a {@code TInt64}
  */
-class TInt64Impl extends LongTensorImpl<TInt64> implements TInt64 {
+class TInt64Impl extends LongTensorImpl implements TInt64 {
 
   TInt64Impl(TF_Tensor nativeTensor, Shape shape) {
     super(nativeTensor, DTYPE, shape, TensorBuffers.toLongs(nativeTensor));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
index ccf8818b048..3f574713be2 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
@@ -22,15 +22,17 @@
 import java.util.function.Function;
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.buffer.ByteSequenceTensorBuffer;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.ByteSequenceTensorBuffer;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.StringTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayout;
 import org.tensorflow.ndarray.buffer.layout.DataLayouts;
+import org.tensorflow.tensor.StringTensor;
 import org.tensorflow.types.family.TType;
 
 /**
@@ -42,7 +44,7 @@
  * its values initially, so TensorFlow can compute and allocate the right amount of memory. Then
  * the data in the tensor is initialized once and cannot be modified afterwards.
  */
-public interface TString extends StringTensor<TString>, TType {
+public interface TString extends StringTensor, TType {
 
   /**
    * Type metadata
@@ -215,7 +217,7 @@ static TString tensorOfBytes(Shape shape, DataBuffer<byte[]> data) {
 /**
  * Hidden implementation of a {@code TString}
  */
-class TStringImpl extends StringTensorImpl<TString> implements TString {
+class TStringImpl extends StringTensorImpl implements TString {
 
   @Override
   public TString using(Charset charset) {
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
index d104d0e409a..8df15d9792f 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
@@ -21,18 +21,20 @@
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.buffer.TensorBuffers;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.ByteTensorImpl;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
 import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.tensor.ByteTensor;
 import org.tensorflow.types.family.TNumber;
 
 /**
  * 8-bit unsigned integer tensor type.
  */
-public interface TUint8 extends ByteTensor<TUint8>, TNumber {
+public interface TUint8 extends ByteTensor, TNumber {
 
   /** Type metadata */
   DataType<TUint8> DTYPE = DataType.create("UINT8", 4, 1, TUint8Impl::new);
@@ -109,7 +111,7 @@ static TUint8 tensorOf(Shape shape, Consumer<TUint8> tensorInit) {
 /**
  * Hidden implementation of a {@code TUint8}
  */
-class TUint8Impl extends ByteTensorImpl<TUint8> implements TUint8 {
+class TUint8Impl extends ByteTensorImpl implements TUint8 {
 
   TUint8Impl(TF_Tensor nativeTensor, Shape shape) {
     super(nativeTensor, DTYPE, shape, TensorBuffers.toBytes(nativeTensor));
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
index b8937c64630..cda67fabe5e 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
@@ -1,5 +1,5 @@
 package org.tensorflow.types.family;
 
-public interface TFloat {
+public interface TFloating extends TNumber {
 
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/package-info.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/package-info.java
index fcf1f554133..79e9e93fea3 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/package-info.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/package-info.java
@@ -21,8 +21,5 @@
  * <p>Some operations enforces that only operands of a type from a given family can be passed
  * in argument. For example, if an operation only allows numeric operands, such operands must be
  * bound to the {@link org.tensorflow.types.family.TNumber TNumber} interface.
- *
- * <p>All tensor types is bound to {@link org.tensorflow.types.family.TType TType}, which lays at
- * the root of the family hierarchy.
  */
 package org.tensorflow.types.family;
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 6802ead9592..8fb3f22cd8d 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
@@ -93,7 +93,7 @@ public void setAttrs() {
     try (EagerSession session = EagerSession.create()) {
       Ops tf = Ops.create(session);
       // dtype, tensor attributes.
-      try (Tensor<TInt32> t = TInt32.scalarOf(1)) {
+      try (TInt32 t = TInt32.scalarOf(1)) {
         opBuilder(session, "Const", "DataTypeAndTensor")
             .setAttr("dtype", TInt32.DTYPE)
             .setAttr("value", t)
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 09d2214cc6a..6f069506f5f 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
@@ -46,7 +46,7 @@ public void failToCreateIfSessionIsClosed() {
   @Test
   public void outputDataTypeAndShape() {
     try (EagerSession session = EagerSession.create();
-         Tensor<TInt32> t = TInt32.tensorOf(Shape.of(2, 3))) {
+         TInt32 t = TInt32.tensorOf(Shape.of(2, 3))) {
       EagerOperation op =
           opBuilder(session, "Const", "OutputAttrs")
               .setAttr("dtype", TInt32.DTYPE)
@@ -67,7 +67,7 @@ public void outputTensor() {
               .addInput(tf.constant(2).asOutput())
               .addInput(tf.constant(4).asOutput())
               .build();
-      assertEquals(6, add.tensor(0).expect(TInt32.DTYPE).data().getInt());
+      assertEquals(6, add.tensor(0).expect(TInt32.DTYPE).getInt());
 
       // Validate that we retrieve the right shape and datatype from the tensor
       // that has been resolved
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 35bfa808238..7573a25ac13 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
@@ -50,7 +50,7 @@ public void failWhenMixingOperationsOnDifferentGraphs() {
   @Test
   public void failOnUseAfterBuild() {
     try (Graph g = new Graph();
-        Tensor<TInt32> t = TInt32.scalarOf(1)) {
+        TInt32 t = TInt32.scalarOf(1)) {
       OperationBuilder b =
           g.opBuilder("Const", "Const").setAttr("dtype", t.dataType()).setAttr("value", t);
       b.build();
@@ -66,7 +66,7 @@ public void failOnUseAfterBuild() {
   public void failOnUseAfterGraphClose() {
     OperationBuilder b = null;
     try (Graph g = new Graph();
-        Tensor<TInt32> t = TInt32.scalarOf(1)) {
+        TInt32 t = TInt32.scalarOf(1)) {
       b = g.opBuilder("Const", "Const").setAttr("dtype", t.dataType()).setAttr("value", t);
     }
     try {
@@ -88,7 +88,7 @@ public void setAttr() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
       // dtype, tensor attributes.
-      try (Tensor<TInt32> t = TInt32.scalarOf(1)) {
+      try (TInt32 t = TInt32.scalarOf(1)) {
         g.opBuilder("Const", "DataTypeAndTensor")
             .setAttr("dtype", TInt32.DTYPE)
             .setAttr("value", t)
@@ -169,8 +169,8 @@ public void setAttrShapeList() {
   public void addControlInput() {
     try (Graph g = new Graph();
         Session s = new Session(g);
-        Tensor<TBool> yes = TBool.scalarOf(true);
-        Tensor<TBool> no = TBool.scalarOf(false)) {
+        TBool yes = TBool.scalarOf(true);
+        TBool no = TBool.scalarOf(false)) {
       Ops tf = Ops.create(g);
       Output<TBool> placeholder = tf.placeholder(TBool.DTYPE).asOutput();
       GraphOperation check =
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 de376015e3f..efa6c09f2a5 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
@@ -157,8 +157,8 @@ public void addGradientsToGraph() {
       assertEquals(TFloat32.DTYPE, grads1[0].dataType());
       assertEquals(TFloat32.DTYPE, grads1[1].dataType());
       
-      try (Tensor<TFloat32> c1 = TFloat32.scalarOf(3.0f);
-          Tensor<TFloat32> c2 = TFloat32.scalarOf(2.0f);
+      try (TFloat32 c1 = TFloat32.scalarOf(3.0f);
+          TFloat32 c2 = TFloat32.scalarOf(2.0f);
           AutoCloseableList<Tensor<?>> outputs = new AutoCloseableList<>(
               s.runner()
                   .feed(x1, c1)
@@ -169,9 +169,9 @@ public void addGradientsToGraph() {
                   .run())) {
      
         assertEquals(3, outputs.size());
-        assertEquals(108.0f, outputs.get(0).expect(TFloat32.DTYPE).data().getFloat(), 0.0f);
-        assertEquals(6.0f, outputs.get(1).expect(TFloat32.DTYPE).data().getFloat(), 0.0f);
-        assertEquals(1.0f, outputs.get(2).expect(TFloat32.DTYPE).data().getFloat(), 0.0f);
+        assertEquals(108.0f, outputs.get(0).expect(TFloat32.DTYPE).getFloat(), 0.0f);
+        assertEquals(6.0f, outputs.get(1).expect(TFloat32.DTYPE).getFloat(), 0.0f);
+        assertEquals(1.0f, outputs.get(2).expect(TFloat32.DTYPE).getFloat(), 0.0f);
       }
     }
   }
@@ -191,14 +191,14 @@ public void addGradientSumsToGraph() {
       assertEquals(1, grad.length);
       assertEquals(TFloat32.DTYPE, grad[0].dataType());
 
-      try (Tensor<TFloat32> c = TFloat32.scalarOf(3.0f);
-          Tensor<TFloat32> output = s.runner()
+      try (TFloat32 c = TFloat32.scalarOf(3.0f);
+          TFloat32 output = s.runner()
               .feed(x, c)
               .fetch(grad[0])
               .run()
               .get(0)
               .expect(TFloat32.DTYPE)) {
-        assertEquals(114.0f, output.data().getFloat(), 0.0f);
+        assertEquals(114.0f, output.getFloat(), 0.0f);
       }
     }
   }
@@ -223,14 +223,14 @@ public void addGradientsWithInitialValuesToGraph() {
       assertEquals(1, grad1.length);
       assertEquals(TFloat32.DTYPE, grad1[0].dataType());
 
-      try (Tensor<TFloat32> c = TFloat32.scalarOf(3.0f);
-          Tensor<TFloat32> output = s.runner()
+      try (TFloat32 c = TFloat32.scalarOf(3.0f);
+          TFloat32 output = s.runner()
               .feed(x, c)
               .fetch(grad1[0])
               .run()
               .get(0)
               .expect(TFloat32.DTYPE)) {
-        assertEquals(108.0f, output.data().getFloat(), 0.0f);
+        assertEquals(108.0f, output.getFloat(), 0.0f);
       }
     }
   }
@@ -284,14 +284,14 @@ public void buildWhileLoopSingleInput() {
           },
           "test_loop");
 
-      try (Tensor<TInt32> c = TInt32.scalarOf(2);
-          Tensor<TInt32> output = s.runner()
+      try (TInt32 c = TInt32.scalarOf(2);
+          TInt32 output = s.runner()
               .feed(input, c)
               .fetch(loopOutputs[0])
               .run()
               .get(0)
               .expect(TInt32.DTYPE)) {
-        assertEquals(16, output.data().getInt()); // ((2^2)^2)
+        assertEquals(16, output.getInt()); // ((2^2)^2)
       }
     }
   }
@@ -320,8 +320,8 @@ public void buildWhileLoopMultipleInputs() {
           },
           "test_loop");
 
-      try (Tensor<TInt32> c1 = TInt32.scalarOf(2);
-          Tensor<TInt32> c2 = TInt32.scalarOf(5);
+      try (TInt32 c1 = TInt32.scalarOf(2);
+          TInt32 c2 = TInt32.scalarOf(5);
           AutoCloseableList<Tensor<?>> outputs =
               new AutoCloseableList<>(
                   s.runner()
@@ -331,8 +331,8 @@ public void buildWhileLoopMultipleInputs() {
                       .fetch(loopOutputs[1])
                       .run())) {
         assertEquals(2, outputs.size());
-        assertEquals(16, outputs.get(0).expect(TInt32.DTYPE).data().getInt()); // ((2^2)^2)
-        assertEquals(625, outputs.get(1).expect(TInt32.DTYPE).data().getInt()); // ((5^2)^2)
+        assertEquals(16, outputs.get(0).expect(TInt32.DTYPE).getInt()); // ((2^2)^2)
+        assertEquals(625, outputs.get(1).expect(TInt32.DTYPE).getInt()); // ((5^2)^2)
       }
     }
   }
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 7faf8c6fbdb..e72c461212b 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
@@ -42,11 +42,11 @@ public void runUsingOperationNames() {
         Session s = new Session(g)) {
       Ops tf = Ops.create(g);
       transpose_A_times_X(tf, new int[][] {{2}, {3}});
-      try (Tensor<TInt32> x = TInt32.tensorOf(StdArrays.ndCopyOf(new int[][] {{5}, {7}}));
+      try (TInt32 x = TInt32.tensorOf(StdArrays.ndCopyOf(new int[][] {{5}, {7}}));
           AutoCloseableList<Tensor<?>> outputs =
               new AutoCloseableList<>(s.runner().feed("X", x).fetch("Y").run())) {
         assertEquals(1, outputs.size());
-        assertEquals(31, outputs.get(0).expect(TInt32.DTYPE).data().getInt(0, 0));
+        assertEquals(31, outputs.get(0).expect(TInt32.DTYPE).getInt(0, 0));
       }
     }
   }
@@ -59,11 +59,11 @@ public void runUsingOperationHandles() {
       transpose_A_times_X(tf, new int[][] {{2}, {3}});
       Output<TInt32> feed = g.operation("X").output(0);
       Output<TInt32> fetch = g.operation("Y").output(0);
-      try (Tensor<TInt32> x = TInt32.tensorOf(StdArrays.ndCopyOf(new int[][] {{5}, {7}}));
+      try (TInt32 x = TInt32.tensorOf(StdArrays.ndCopyOf(new int[][] {{5}, {7}}));
           AutoCloseableList<Tensor<?>> outputs =
               new AutoCloseableList<>(s.runner().feed(feed, x).fetch(fetch).run())) {
         assertEquals(1, outputs.size());
-        assertEquals(31, outputs.get(0).expect(TInt32.DTYPE).data().getInt(0, 0));
+        assertEquals(31, outputs.get(0).expect(TInt32.DTYPE).getInt(0, 0));
       }
     }
   }
@@ -77,14 +77,14 @@ public void runUsingColonSeparatedNames() {
       tf.math.add(split.output().get(0), split.output().get(1));
 
       // Fetch using colon separated names.
-      try (Tensor<TInt32> fetched =
+      try (TInt32 fetched =
           s.runner().fetch("Split:1").run().get(0).expect(TInt32.DTYPE)) {
-        assertEquals(3, fetched.data().getInt(0));
-        assertEquals(4, fetched.data().getInt(1));
+        assertEquals(3, fetched.getInt(0));
+        assertEquals(4, fetched.getInt(1));
       }
       // Feed using colon separated names.
-      try (Tensor<TInt32> fed = TInt32.vectorOf(4, 3, 2, 1);
-          Tensor<TInt32> fetched =
+      try (TInt32 fed = TInt32.vectorOf(4, 3, 2, 1);
+          TInt32 fetched =
               s.runner()
                   .feed("Split:0", fed)
                   .feed("Split:1", fed)
@@ -92,7 +92,7 @@ public void runUsingColonSeparatedNames() {
                   .run()
                   .get(0)
                   .expect(TInt32.DTYPE)) {
-        assertEquals(NdArrays.vectorOf(8, 6, 4, 2), fetched.data());
+        assertEquals(NdArrays.vectorOf(8, 6, 4, 2), fetched);
       }
     }
   }
@@ -103,7 +103,7 @@ public void runWithMetadata() {
         Session s = new Session(g)) {
       Ops tf = Ops.create(g);
       transpose_A_times_X(tf, new int[][] {{2}, {3}});
-      try (Tensor<TInt32> x = TInt32.tensorOf(StdArrays.ndCopyOf(new int[][] {{5}, {7}}))) {
+      try (TInt32 x = TInt32.tensorOf(StdArrays.ndCopyOf(new int[][] {{5}, {7}}))) {
         Session.Run result =
             s.runner()
                 .feed("X", x)
@@ -113,7 +113,7 @@ public void runWithMetadata() {
         // Sanity check on outputs.
         AutoCloseableList<Tensor<?>> outputs = new AutoCloseableList<>(result.outputs);
         assertEquals(1, outputs.size());
-        assertEquals(31, outputs.get(0).expect(TInt32.DTYPE).data().getInt(0, 0));
+        assertEquals(31, outputs.get(0).expect(TInt32.DTYPE).getInt(0, 0));
         // Sanity check on metadata
         assertNotNull(result.metadata);
         assertTrue(result.metadata.hasStepStats(), result.metadata.toString());
@@ -132,8 +132,8 @@ public void runMultipleOutputs() {
       AutoCloseableList<Tensor<?>> outputs =
           new AutoCloseableList<>(s.runner().fetch("c2").fetch("c1").run());
       assertEquals(2, outputs.size());
-      assertEquals(31415, outputs.get(0).expect(TInt32.DTYPE).data().getInt());
-      assertEquals(2718, outputs.get(1).expect(TInt32.DTYPE).data().getInt());
+      assertEquals(31415, outputs.get(0).expect(TInt32.DTYPE).getInt());
+      assertEquals(2718, outputs.get(1).expect(TInt32.DTYPE).getInt());
       outputs.close();
     }
   }
@@ -171,8 +171,8 @@ public void runInit() {
       try (Session s = new Session(g)) {
         s.run(tf.init());
 
-        try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
-          assertEquals(30, t.data().getInt());
+        try (TInt32 t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
+          assertEquals(30, t.getInt());
         }
       }
     }
@@ -192,8 +192,8 @@ public void runInitByName() {
       try (Session s = new Session(g)) {
         s.run("init_test");
 
-        try (Tensor<TInt32> t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
-          assertEquals(30, t.data().getInt());
+        try (TInt32 t = s.runner().fetch(add).run().get(0).expect(TInt32.DTYPE)) {
+          assertEquals(30, t.getInt());
         }
         try {
           s.run("wrong_name");
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 6c60480dfda..162f1ac1c95 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
@@ -64,22 +64,22 @@ public void createWithRawData() {
     String strings = "test";
     Shape strings_shape = Shape.scalar();
     byte[] strings_; // raw TF_STRING
-    try (Tensor<TString> t = TString.tensorOf(NdArrays.scalarOfObject(strings))) {
+    try (TString t = TString.tensorOf(NdArrays.scalarOfObject(strings))) {
       strings_ = new byte[(int)t.numBytes()];
       t.rawData().read(strings_);
     }
 
     // validate creating a tensor using a raw data byte buffers
     {
-      try (Tensor<TBool> t = Tensor.of(TBool.DTYPE, bools_shape, DataBuffers.of(bools_))) {
+      try (TBool t = Tensor.of(TBool.DTYPE, bools_shape, DataBuffers.of(bools_))) {
         boolean[] actual = new boolean[bools_.length];
-        t.data().read(DataBuffers.of(actual));
+        t.read(DataBuffers.of(actual));
         assertArrayEquals(bools, actual);
       }
 
       // note: the buffer is expected to contain raw TF_STRING (as per C API)
-      try (Tensor<TString> t = Tensor.of(TString.DTYPE, strings_shape, DataBuffers.of(strings_))) {
-        assertEquals(strings, t.data().getObject());
+      try (TString t = Tensor.of(TString.DTYPE, strings_shape, DataBuffers.of(strings_))) {
+        assertEquals(strings, t.getObject());
       }
     }
 
@@ -87,15 +87,15 @@ public void createWithRawData() {
     {
       DoubleBuffer buf = ByteBuffer.allocateDirect(8 * doubles.length).order(ByteOrder.nativeOrder())
           .asDoubleBuffer().put(doubles);
-      try (Tensor<TFloat64> t = TFloat64.tensorOf(doubles_shape, d -> d.write(DataBuffers.of(buf)))) {
+      try (TFloat64 t = TFloat64.tensorOf(doubles_shape, d -> d.write(DataBuffers.of(buf)))) {
         double[] actual = new double[doubles.length];
-        t.data().read(DataBuffers.of(actual));
+        t.read(DataBuffers.of(actual));
         assertArrayEquals(doubles, actual, EPSILON);
       }
     }
 
     // validate shape checking
-    try (Tensor<TBool> t = Tensor.of(TBool.DTYPE, Shape.of(bools_.length * 2), DataBuffers.of(bools_))) {
+    try (TBool t = Tensor.of(TBool.DTYPE, Shape.of(bools_.length * 2), DataBuffers.of(bools_))) {
       fail("should have failed on incompatible buffer");
     } catch (IllegalArgumentException e) {
       // expected
@@ -111,9 +111,9 @@ public void createFromBufferWithNativeByteOrder() {
             .asDoubleBuffer()
             .put(doubles);
     flipBuffer(buf);
-    try (Tensor<TFloat64> t = TFloat64.tensorOf(Shape.of(4), DataBuffers.of(buf))) {
+    try (TFloat64 t = TFloat64.tensorOf(Shape.of(4), DataBuffers.of(buf))) {
       double[] actual = new double[doubles.length];
-      t.data().read(DataBuffers.of(actual));
+      t.read(DataBuffers.of(actual));
       assertArrayEquals(doubles, actual, EPSILON);
     }
   }
@@ -130,9 +130,9 @@ public void createFromBufferWithNonNativeByteOrder() {
             .asDoubleBuffer()
             .put(doubles);
     flipBuffer(buf);
-    try (Tensor<TFloat64> t = TFloat64.tensorOf(Shape.of(4), DataBuffers.of(buf))) {
+    try (TFloat64 t = TFloat64.tensorOf(Shape.of(4), DataBuffers.of(buf))) {
       double[] actual = new double[doubles.length];
-      t.data().read(DataBuffers.of(actual));
+      t.read(DataBuffers.of(actual));
       assertArrayEquals(doubles, actual, EPSILON);
     }
   }
@@ -147,24 +147,24 @@ public void createWithTypedBuffer() {
     // validate creating a tensor using a typed buffer
     {
       Shape shape = Shape.of(4);
-      try (Tensor<TFloat64> t = TFloat64.tensorOf(shape, DataBuffers.of(doubles))) {
+      try (TFloat64 t = TFloat64.tensorOf(shape, DataBuffers.of(doubles))) {
         DoubleBuffer actual = DoubleBuffer.allocate(doubles.capacity());
-        t.data().read(DataBuffers.of(actual));
+        t.read(DataBuffers.of(actual));
         assertEquals(doubles, actual);
       }
-      try (Tensor<TFloat32> t = TFloat32.tensorOf(shape, DataBuffers.of(floats))) {
+      try (TFloat32 t = TFloat32.tensorOf(shape, DataBuffers.of(floats))) {
         FloatBuffer actual = FloatBuffer.allocate(floats.capacity());
-        t.data().read(DataBuffers.of(actual));
+        t.read(DataBuffers.of(actual));
         assertEquals(floats, actual);
       }
-      try (Tensor<TInt32> t = TInt32.tensorOf(shape, DataBuffers.of(ints))) {
+      try (TInt32 t = TInt32.tensorOf(shape, DataBuffers.of(ints))) {
         IntBuffer actual = IntBuffer.allocate(ints.capacity());
-        t.data().read(DataBuffers.of(actual));
+        t.read(DataBuffers.of(actual));
         assertEquals(ints, actual);
       }
-      try (Tensor<TInt64> t = TInt64.tensorOf(shape, DataBuffers.of(longs))) {
+      try (TInt64 t = TInt64.tensorOf(shape, DataBuffers.of(longs))) {
         LongBuffer actual = LongBuffer.allocate(longs.capacity());
-        t.data().read(DataBuffers.of(actual));
+        t.read(DataBuffers.of(actual));
         assertEquals(longs, actual);
       }
     }
@@ -172,22 +172,22 @@ public void createWithTypedBuffer() {
     // validate shape-checking
     {
       Shape shape = Shape.of(5);
-      try (Tensor<TFloat64> t = TFloat64.tensorOf(shape, DataBuffers.of(doubles))) {
+      try (TFloat64 t = TFloat64.tensorOf(shape, DataBuffers.of(doubles))) {
         fail("should have failed on incompatible buffer");
       } catch (BufferUnderflowException e) {
         // expected
       }
-      try (Tensor<TFloat32> t = TFloat32.tensorOf(shape, DataBuffers.of(floats))) {
+      try (TFloat32 t = TFloat32.tensorOf(shape, DataBuffers.of(floats))) {
         fail("should have failed on incompatible buffer");
       } catch (BufferUnderflowException e) {
         // expected
       }
-      try (Tensor<TInt32> t = TInt32.tensorOf(shape, DataBuffers.of(ints))) {
+      try (TInt32 t = TInt32.tensorOf(shape, DataBuffers.of(ints))) {
         fail("should have failed on incompatible buffer");
       } catch (BufferUnderflowException e) {
         // expected
       }
-      try (Tensor<TInt64> t = TInt64.tensorOf(shape, DataBuffers.of(longs))) {
+      try (TInt64 t = TInt64.tensorOf(shape, DataBuffers.of(longs))) {
         fail("should have failed on incompatible buffer");
       } catch (BufferUnderflowException e) {
         // expected
@@ -203,11 +203,11 @@ public void readFromRawData() {
     long[] longs = {1L, 2L, 3L};
     boolean[] bools = {true, false, true};
 
-    try (Tensor<TInt32> tints = TInt32.vectorOf(ints);
-        Tensor<TFloat32> tfloats = TFloat32.vectorOf(floats);
-        Tensor<TFloat64> tdoubles = TFloat64.vectorOf(doubles);
-        Tensor<TInt64> tlongs = TInt64.vectorOf(longs);
-        Tensor<TBool> tbools = TBool.vectorOf(bools)) {
+    try (TInt32 tints = TInt32.vectorOf(ints);
+        TFloat32 tfloats = TFloat32.vectorOf(floats);
+        TFloat64 tdoubles = TFloat64.vectorOf(doubles);
+        TInt64 tlongs = TInt64.vectorOf(longs);
+        TBool tbools = TBool.vectorOf(bools)) {
 
       // validate that any datatype is readable with ByteBuffer (content, position)
       {
@@ -266,79 +266,79 @@ public void readFromRawData() {
 
   @Test
   public void scalars() {
-    try (Tensor<TFloat32> t = TFloat32.scalarOf(2.718f)) {
+    try (TFloat32 t = TFloat32.scalarOf(2.718f)) {
       assertEquals(TFloat32.DTYPE, t.dataType());
       assertEquals(0, t.shape().numDimensions());
-      assertEquals(2.718f, t.data().getFloat(), EPSILON_F);
+      assertEquals(2.718f, t.getFloat(), EPSILON_F);
     }
 
-    try (Tensor<TFloat64> t = TFloat64.scalarOf(3.1415)) {
+    try (TFloat64 t = TFloat64.scalarOf(3.1415)) {
       assertEquals(TFloat64.DTYPE, t.dataType());
       assertEquals(0, t.shape().numDimensions());
-      assertEquals(3.1415, t.data().getDouble(), EPSILON);
+      assertEquals(3.1415, t.getDouble(), EPSILON);
     }
 
-    try (Tensor<TInt32> t = TInt32.scalarOf(-33)) {
+    try (TInt32 t = TInt32.scalarOf(-33)) {
       assertEquals(TInt32.DTYPE, t.dataType());
       assertEquals(0, t.shape().numDimensions());
-      assertEquals(-33, t.data().getInt());
+      assertEquals(-33, t.getInt());
     }
 
-    try (Tensor<TInt64> t = TInt64.scalarOf(8589934592L)) {
+    try (TInt64 t = TInt64.scalarOf(8589934592L)) {
       assertEquals(TInt64.DTYPE, t.dataType());
       assertEquals(0, t.shape().numDimensions());
-      assertEquals(8589934592L, t.data().getLong());
+      assertEquals(8589934592L, t.getLong());
     }
 
-    try (Tensor<TBool> t = TBool.scalarOf(true)) {
+    try (TBool t = TBool.scalarOf(true)) {
       assertEquals(TBool.DTYPE, t.dataType());
       assertEquals(0, t.shape().numDimensions());
-      assertTrue(t.data().getBoolean());
+      assertTrue(t.getBoolean());
     }
 
-    try (Tensor<TString> t = TString.scalarOf("sombrero")) {
+    try (TString t = TString.scalarOf("sombrero")) {
       assertEquals(TString.DTYPE, t.dataType());
       assertEquals(0, t.shape().numDimensions());
-      assertEquals("sombrero", t.data().getObject());
+      assertEquals("sombrero", t.getObject());
     }
 
     final byte[] bytes = {1, 2, 3, 4};
-    try (Tensor<TString> t = TString.tensorOfBytes(NdArrays.scalarOfObject(bytes))) {
+    try (TString t = TString.tensorOfBytes(NdArrays.scalarOfObject(bytes))) {
       assertEquals(TString.DTYPE, t.dataType());
       assertEquals(0, t.shape().numDimensions());
-      assertArrayEquals(bytes, t.data().asBytes().getObject());
+      assertArrayEquals(bytes, t.asBytes().getObject());
     }
   }
 
   @Test
   public void nDimensional() {
     DoubleNdArray vector = StdArrays.ndCopyOf(new double[]{1.414, 2.718, 3.1415});
-    try (Tensor<TFloat64> t = TFloat64.tensorOf(vector)) {
+    try (TFloat64 t = TFloat64.tensorOf(vector)) {
       assertEquals(TFloat64.DTYPE, t.dataType());
       assertEquals(1, t.shape().numDimensions());
       assertEquals(3, t.shape().size(0));
-      assertEquals(vector, t.data());
+      assertEquals(vector, t);
     }
 
     IntNdArray matrix = StdArrays.ndCopyOf(new int[][]{{1, 2, 3}, {4, 5, 6}});
-    try (Tensor<TInt32> t = TInt32.tensorOf(matrix)) {
+    try (TInt32 t = TInt32.tensorOf(matrix)) {
       assertEquals(TInt32.DTYPE, t.dataType());
       assertEquals(2, t.shape().numDimensions());
       assertEquals(2, t.shape().size(0));
       assertEquals(3, t.shape().size(1));
-      assertEquals(matrix, t.data());
+      assertEquals(matrix, t);
     }
 
     LongNdArray threeD = StdArrays.ndCopyOf(new long[][][]{
       {{1}, {3}, {5}, {7}, {9}}, {{2}, {4}, {6}, {8}, {0}},
     });
-    try (Tensor<TInt64> t = TInt64.tensorOf(threeD)) {
+    try (TInt64 t = TInt64.tensorOf(threeD)) {
       assertEquals(TInt64.DTYPE, t.dataType());
       assertEquals(3, t.shape().numDimensions());
       assertEquals(2, t.shape().size(0));
       assertEquals(5, t.shape().size(1));
       assertEquals(1, t.shape().size(2));
-      assertEquals(threeD, t.data());
+      assertEquals(threeD, t);
     }
 
     BooleanNdArray fourD = StdArrays.ndCopyOf(new boolean[][][][]{
@@ -346,14 +346,14 @@ public void nDimensional() {
       {{{false, false, true, true}, {false, true, false, false}}},
       {{{false, true, false, true}, {false, true, true, false}}},
     });
-    try (Tensor<TBool> t = TBool.tensorOf(fourD)) {
+    try (TBool t = TBool.tensorOf(fourD)) {
       assertEquals(TBool.DTYPE, t.dataType());
       assertEquals(4, t.shape().numDimensions());
       assertEquals(3, t.shape().size(0));
       assertEquals(1, t.shape().size(1));
       assertEquals(2, t.shape().size(2));
       assertEquals(4, t.shape().size(3));
-      assertEquals(fourD, t.data());
+      assertEquals(fourD, t);
     }
   }
 
@@ -365,36 +365,36 @@ public void testNDimensionalStringTensor() {
         matrix.setObject(String.format("(%d, %d) = %d", i, j, i << j), i, j);
       }
     }
-    try (Tensor<TString> t = TString.tensorOf(matrix)) {
+    try (TString t = TString.tensorOf(matrix)) {
       assertEquals(TString.DTYPE, t.dataType());
       assertEquals(2, t.shape().numDimensions());
       assertEquals(4, t.shape().size(0));
       assertEquals(3, t.shape().size(1));
-      assertEquals(matrix, t.data());
+      assertEquals(matrix, t);
     }
 
     NdArray<byte[]> byteMatrix = NdArrays.ofObjects(byte[].class, matrix.shape());
     matrix.scalars().forEachIndexed((i, s) -> byteMatrix.setObject(s.getObject().getBytes(UTF_8), i));
-    try (Tensor<TString> t = TString.tensorOfBytes(byteMatrix)) {
+    try (TString t = TString.tensorOfBytes(byteMatrix)) {
       assertEquals(TString.DTYPE, t.dataType());
       assertEquals(2, t.shape().numDimensions());
       assertEquals(4, t.shape().size(0));
       assertEquals(3, t.shape().size(1));
-      assertEquals(byteMatrix, t.data().asBytes());
-      assertEquals(matrix, t.data());
+      assertEquals(byteMatrix, t.asBytes());
+      assertEquals(matrix, t);
     }
   }
 
   @Test
   public void testUint8TensorFromArray() {
     byte[] vector = new byte[] {1, 2, 3, 4};
-    try (Tensor<TUint8> t = TUint8.vectorOf(vector)) {
+    try (TUint8 t = TUint8.vectorOf(vector)) {
       assertEquals(TUint8.DTYPE, t.dataType());
       assertEquals(1, t.shape().numDimensions());
       assertEquals(4, t.shape().size(0));
 
       byte[] got = new byte[4];
-      t.data().read(DataBuffers.of(got));
+      t.read(DataBuffers.of(got));
       assertArrayEquals(vector, got);
     }
   }
@@ -402,13 +402,13 @@ public void testUint8TensorFromArray() {
   @Test
   public void testCreateFromArrayOfBoxed() {
     Integer[] vector = new Integer[] {1, 2, 3, 4};
-    try (Tensor<TInt32> t = TInt32.tensorOf(Shape.of(4), d -> d.write(DataBuffers.ofObjects(vector)))) {
+    try (TInt32 t = TInt32.tensorOf(Shape.of(4), d -> d.write(DataBuffers.ofObjects(vector)))) {
       assertEquals(TInt32.DTYPE, t.dataType());
       assertEquals(1, t.shape().numDimensions());
       assertEquals(4, t.shape().size(0));
 
       Integer[] got = new Integer[4];
-      t.data().read(DataBuffers.ofObjects(got));
+      t.read(DataBuffers.ofObjects(got));
       assertArrayEquals(vector, got);
     }
   }
@@ -421,7 +421,7 @@ public void failCreateOnMismatchedDimensions() {
         invalid[x][y] = new int[x + y + 1];
       }
     }
-    try (Tensor<TInt32> t = TInt32.tensorOf(StdArrays.ndCopyOf(invalid))) {
+    try (TInt32 t = TInt32.tensorOf(StdArrays.ndCopyOf(invalid))) {
       fail("Tensor.create() should fail because of differing sizes in the 3rd dimension");
     } catch (IllegalArgumentException e) {
       // The expected exception.
@@ -433,11 +433,11 @@ public void tensorWithZeroDimension() {
     // Note: Historically, TF Java failed on purpose when trying to allocate a tensor with a shape
     // that has one or more dimensions set to 0 elements. But Python API allows it, so we should do
     // the same.
-    try (Tensor<TInt32> t = TInt32.tensorOf(Shape.of(3, 0, 1))) {
+    try (TInt32 t = TInt32.tensorOf(Shape.of(3, 0, 1))) {
       assertEquals(0, t.numBytes());
       assertEquals(0, t.shape().size());
     }
-    try (Tensor<TInt32> t = TInt32.tensorOf(StdArrays.ndCopyOf(new int[3][0][1]))) {
+    try (TInt32 t = TInt32.tensorOf(StdArrays.ndCopyOf(new int[3][0][1]))) {
       assertEquals(0, t.numBytes());
       assertEquals(0, t.shape().size());
     }
@@ -445,10 +445,10 @@ public void tensorWithZeroDimension() {
 
   @Test
   public void allocateTensorWithSize() {
-    try (Tensor<TInt32> t = Tensor.of(TInt32.DTYPE, Shape.of(2, 2, 2), 8 * TInt32.DTYPE.byteSize())) {
+    try (TInt32 t = Tensor.of(TInt32.DTYPE, Shape.of(2, 2, 2), 8 * TInt32.DTYPE.byteSize())) {
       // ok
     }
-    try (Tensor<TInt32> t = Tensor.of(TInt32.DTYPE, Shape.of(2, 2, 2), 9 * TInt32.DTYPE.byteSize())) {
+    try (TInt32 t = Tensor.of(TInt32.DTYPE, Shape.of(2, 2, 2), 9 * TInt32.DTYPE.byteSize())) {
       // ok (size requested is larger that minimum space required)
     }
     try {
@@ -473,12 +473,12 @@ public void useAfterClose() {
 
   @Test
   public void eagerTensorIsReleasedAfterSessionIsClosed() {
-    Tensor<TInt32> sum;
+    TInt32 sum;
     try (EagerSession session = EagerSession.create()) {
       Ops tf = Ops.create(session);
       sum = tf.math.add(tf.constant(10), tf.constant(20)).asTensor();
       sum.nativeHandle(); // does not throw
-      assertEquals(30, sum.data().getInt());
+      assertEquals(30, sum.getInt());
     }
     try {
       sum.nativeHandle();
@@ -487,7 +487,7 @@ public void eagerTensorIsReleasedAfterSessionIsClosed() {
       // as expected
     }
     try {
-      sum.data().getInt();
+      sum.getInt();
       fail("Tensor data should not be accessible after tensor is closed");
     } catch (IllegalStateException e) {
       // as expected
@@ -503,12 +503,12 @@ public void fromHandle() {
     // An exception is made for this test, where the pitfalls of this is avoided by not calling
     // close() on both Tensors.
     final FloatNdArray matrix = StdArrays.ndCopyOf(new float[][]{{1, 2, 3}, {4, 5, 6}});
-    try (Tensor<TFloat32> src = TFloat32.tensorOf(matrix)) {
-      Tensor<TFloat32> cpy = Tensors.fromHandle(src.nativeHandle()).expect(TFloat32.DTYPE);
+    try (TFloat32 src = TFloat32.tensorOf(matrix)) {
+      TFloat32 cpy = Tensors.fromHandle(src.nativeHandle()).expect(TFloat32.DTYPE);
       assertEquals(src.dataType(), cpy.dataType());
       assertEquals(src.shape().numDimensions(), cpy.shape().numDimensions());
       assertEquals(src.shape(), cpy.shape());
-      assertEquals(matrix, cpy.data());
+      assertEquals(matrix, cpy);
     }
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java
index bbebfd5f454..288c7d7b18b 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java
@@ -25,7 +25,6 @@
 import org.tensorflow.Session;
 import org.tensorflow.Tensor;
 import org.tensorflow.types.TInt32;
-import org.tensorflow.types.family.TType;
 
 /** Unit tests for {@link org.tensorflow.op.Scope}. */
 public class ScopeTest {
@@ -169,16 +168,16 @@ public void composite() {
       // assertNotNull(g.operation("variance/zero"));
 
       // Verify correct results as well.
-      Tensor<TInt32> result =
+      TInt32 result =
           sess.runner().fetch(var1.output()).run().get(0).expect(TInt32.DTYPE);
-      assertEquals(21704, result.data().getInt());
+      assertEquals(21704, result.getInt());
       result = sess.runner().fetch(var2.output()).run().get(0).expect(TInt32.DTYPE);
-      assertEquals(21704, result.data().getInt());
+      assertEquals(21704, result.getInt());
     }
   }
 
   // "handwritten" sample operator classes
-  private static final class Const<T extends TType> {
+  private static final class Const<T extends Tensor> {
     private final Output<T> output;
 
     static Const<TInt32> create(Scope s, int v) {
@@ -189,7 +188,7 @@ static Const<TInt32> create(Scope s, int[] v) {
       return create(s, TInt32.vectorOf(v));
     }
 
-    static <T extends TType> Const<T> create(Scope s, Tensor<T> value) {
+    static <T extends Tensor> Const<T> create(Scope s, T value) {
       return new Const<>(
           s.env()
               .opBuilder("Const", s.makeOpName("Const"))
@@ -208,10 +207,10 @@ Output<T> output() {
     }
   }
 
-  private static final class Mean<T extends TType> {
+  private static final class Mean<T extends Tensor> {
     private final Output<T> output;
 
-    static <T extends TType> Mean<T> create(Scope s, Output<T> input, Output<T> reductionIndices) {
+    static <T extends Tensor> Mean<T> create(Scope s, Output<T> input, Output<T> reductionIndices) {
       return new Mean<>(
           s.env()
               .opBuilder("Mean", s.makeOpName("Mean"))
@@ -230,10 +229,10 @@ Output<T> output() {
     }
   }
 
-  private static final class SquaredDifference<T extends TType> {
+  private static final class SquaredDifference<T extends Tensor> {
     private final Output<T> output;
 
-    static <T extends TType> SquaredDifference<T> create(Scope s, Output<T> x, Output<T> y) {
+    static <T extends Tensor> SquaredDifference<T> create(Scope s, Output<T> x, Output<T> y) {
       return new SquaredDifference<>(
           s.env()
               .opBuilder("SquaredDifference", s.makeOpName("SquaredDifference"))
@@ -252,7 +251,7 @@ Output<T> output() {
     }
   }
 
-  private static final class Variance<T extends TType> {
+  private static final class Variance<T extends Tensor> {
     private final Output<T> output;
 
     static Variance<TInt32> create(Scope base, Output<TInt32> x) {
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 a337bd73098..8d0c4764a91 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
@@ -36,8 +36,8 @@ public void tensorInputTensorOutput() {
         Session sess = new Session(g)) {
       Ops ops = Ops.create(g);
       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());
+      try (TInt32 result = sess.runner().fetch(x).run().get(0).expect(TInt32.DTYPE)) {
+        assertEquals(3, result.getInt());
       }
     }
   }
@@ -52,8 +52,8 @@ public void testListInputTensorOutput() {
       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());
+      try (TInt32 result = sess.runner().fetch(x).run().get(0).expect(TInt32.DTYPE)) {
+        assertEquals(6, result.getInt());
       }
     }
   }
@@ -77,8 +77,8 @@ public void testControlDependencies() {
       Operand<TInt32> x =
           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());
+      try (TInt32 result = sess.runner().fetch(x).run().get(0).expect(TInt32.DTYPE)) {
+        assertEquals(3, result.getInt());
       }
     }
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GradientsTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GradientsTest.java
index fe1503d415f..3303904f9e6 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GradientsTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/GradientsTest.java
@@ -47,13 +47,13 @@ public void createGradients() {
       assertNotNull(grads.dy());
       assertEquals(2, grads.dy().size());
 
-      try (Tensor<TFloat32> c = TFloat32.scalarOf(3.0f);
+      try (TFloat32 c = TFloat32.scalarOf(3.0f);
           AutoCloseableList<Tensor<?>> outputs =
               new AutoCloseableList<>(
                   sess.runner().feed(x, c).fetch(grads.dy(0)).fetch(grads.dy(1)).run())) {
 
-        assertEquals(108.0f, outputs.get(0).expect(TFloat32.DTYPE).data().getFloat(), 0.0f);
-        assertEquals(18.0f, outputs.get(1).expect(TFloat32.DTYPE).data().getFloat(), 0.0f);
+        assertEquals(108.0f, outputs.get(0).expect(TFloat32.DTYPE).getFloat(), 0.0f);
+        assertEquals(18.0f, outputs.get(1).expect(TFloat32.DTYPE).getFloat(), 0.0f);
       }
     }
   }
@@ -74,11 +74,11 @@ public void createGradientsWithSum() {
       assertNotNull(grads.dy());
       assertEquals(1, grads.dy().size());
 
-      try (Tensor<TFloat32> c = TFloat32.scalarOf(3.0f);
+      try (TFloat32 c = TFloat32.scalarOf(3.0f);
           AutoCloseableList<Tensor<?>> outputs =
               new AutoCloseableList<>(sess.runner().feed(x, c).fetch(grads.dy(0)).run())) {
 
-        assertEquals(114.0f, outputs.get(0).expect(TFloat32.DTYPE).data().getFloat(), 0.0f);
+        assertEquals(114.0f, outputs.get(0).expect(TFloat32.DTYPE).getFloat(), 0.0f);
       }
     }
   }
@@ -100,12 +100,12 @@ public void createGradientsWithInitialValues() {
       assertNotNull(grads1.dy());
       assertEquals(1, grads1.dy().size());
 
-      try (Tensor<TFloat32> c = TFloat32.scalarOf(3.0f);
+      try (TFloat32 c = TFloat32.scalarOf(3.0f);
           AutoCloseableList<Tensor<?>> outputs =
               new AutoCloseableList<>(
                   sess.runner().feed(x, c).fetch(grads1.dy(0)).run())) {
 
-        assertEquals(108.0f, outputs.get(0).expect(TFloat32.DTYPE).data().getFloat(), 0.0f);
+        assertEquals(108.0f, outputs.get(0).expect(TFloat32.DTYPE).getFloat(), 0.0f);
       }
     }
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ShapesTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ShapesTest.java
index d5eb7412ea3..583b3d14a0f 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ShapesTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ShapesTest.java
@@ -47,15 +47,15 @@ public void testFlatten_Operand() {
       Shape<TInt64> tfshape = Shape.create(scope, actual, TInt64.DTYPE);
 
       AtomicInteger index = new AtomicInteger();
-      try (Tensor<TInt64> result1 =
+      try (TInt64 result1 =
               session.runner().fetch(tfshape.asOutput()).run().get(0).expect(TInt64.DTYPE);
-          Tensor<TInt64> result2 =
+          TInt64 result2 =
               session.runner().fetch(expResult.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
         result1
-            .data()
+
             .scalars()
             .forEach(
-                s -> assertEquals(result2.data().getLong(index.getAndIncrement()), s.getLong()));
+                s -> assertEquals(result2.getLong(index.getAndIncrement()), s.getLong()));
       }
     }
   }
@@ -75,12 +75,12 @@ public void testFlatten_Shape() {
       AtomicInteger index = new AtomicInteger();
       flattened
           .asOutput()
-          .data()
+          .asTensor()
           .scalars()
           .forEach(
               s ->
                   assertEquals(
-                      expShape.asOutput().data().getLong(index.getAndIncrement()), s.getLong()));
+                      expShape.asTensor().getLong(index.getAndIncrement()), s.getLong()));
     }
   }
 
@@ -97,9 +97,9 @@ public void testSize_Shape() {
       Operand<TInt64> size = Shapes.size(scope, tfshape, TInt64.DTYPE);
 
       AtomicInteger index = new AtomicInteger();
-      try (Tensor<TInt64> result1 =
+      try (TInt64 result1 =
           session.runner().fetch(size.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
-        result1.data().scalars().forEach(s -> assertEquals(8, s.getLong()));
+        result1.scalars().forEach(s -> assertEquals(8, s.getLong()));
       }
     }
   }
@@ -116,21 +116,21 @@ public void testSize_Shape_Operand() {
       Shape<TInt32> tfshape = Shape.create(scope, actual);
 
       Operand<TInt32> size = Shapes.size(scope, tfshape, Constant.scalarOf(scope, 0));
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(size.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(4, s.getInt()));
+        result.scalars().forEach(s -> assertEquals(4, s.getInt()));
       }
 
       size = Shapes.size(scope, tfshape, Constant.scalarOf(scope, 1));
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(size.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(2, s.getInt()));
+        result.scalars().forEach(s -> assertEquals(2, s.getInt()));
       }
 
       size = Shapes.size(scope, tfshape, Constant.scalarOf(scope, 2));
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(size.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(1, s.getInt()));
+        result.scalars().forEach(s -> assertEquals(1, s.getInt()));
       }
     }
   }
@@ -146,21 +146,21 @@ public void testSize_Operand_Operand() {
           Reshape.create(scope, operand, Constant.vectorOf(scope, new long[] {4, 2, 1}));
 
       Operand<TInt32> size = Shapes.size(scope, actual, Constant.scalarOf(scope, 0));
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(size.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(4, s.getInt()));
+        result.scalars().forEach(s -> assertEquals(4, s.getInt()));
       }
 
       size = Shapes.size(scope, actual, Constant.scalarOf(scope, 1));
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(size.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(2, s.getInt()));
+        result.scalars().forEach(s -> assertEquals(2, s.getInt()));
       }
 
       size = Shapes.size(scope, actual, Constant.scalarOf(scope, 2));
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(size.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(1, s.getInt()));
+        result.scalars().forEach(s -> assertEquals(1, s.getInt()));
       }
     }
   }
@@ -177,9 +177,9 @@ public void testNumDimensions() {
       Shape<TInt32> tfshape = Shape.create(scope, actual);
 
       Operand<TInt32> nDims = Shapes.numDimensions(scope, tfshape);
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(nDims.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(3, s.getInt()));
+        result.scalars().forEach(s -> assertEquals(3, s.getInt()));
       }
     }
   }
@@ -199,7 +199,7 @@ public void testReduceDims_Operand_Operand() {
       AtomicInteger index = new AtomicInteger();
       int[] expected = {8};
       reducedShape
-          .data()
+          .asTensor()
           .scalars()
           .forEach(
               s -> {
@@ -224,7 +224,7 @@ public void testReduceDims_Shape_Operand() {
       AtomicInteger index = new AtomicInteger();
       int[] expected1 = {8};
       reducedShape
-          .data()
+          .asTensor()
           .scalars()
           .forEach(
               s -> {
@@ -237,7 +237,7 @@ public void testReduceDims_Shape_Operand() {
       index.set(0);
       int[] expected2 = {2, 4};
       reducedShape
-          .data()
+          .asTensor()
           .scalars()
           .forEach(
               s -> {
@@ -250,7 +250,7 @@ public void testReduceDims_Shape_Operand() {
       index.set(0);
       int[] expected3 = {2, 2, 2};
       reducedShape
-          .data()
+          .asTensor()
           .scalars()
           .forEach(
               s -> {
@@ -274,10 +274,10 @@ public void testSqueeze() {
       Operand<TInt32> squeezed = Shapes.squeeze(scope, tfshape);
       AtomicInteger index = new AtomicInteger();
       int[] expected = {4, 2};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(squeezed.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -301,10 +301,10 @@ public void testHead() {
       Operand<TInt32> head = Shapes.head(scope, tfshape);
       AtomicInteger index = new AtomicInteger();
       int[] expected = {4};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(head.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -328,10 +328,10 @@ public void testTake() {
       Operand<TInt32> take = Shapes.take(scope, tfshape, Constant.scalarOf(scope, 2));
       AtomicInteger index = new AtomicInteger();
       int[] expected = {4, 1};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(take.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -355,10 +355,10 @@ public void testTail() {
       Operand<TInt32> tail = Shapes.tail(scope, tfshape);
       AtomicInteger index = new AtomicInteger();
       int[] expected = {1};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(tail.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -382,10 +382,10 @@ public void testTakeLast() {
       Operand<TInt32> takeLast = Shapes.takeLast(scope, tfshape, Constant.scalarOf(scope, 3));
       AtomicInteger index = new AtomicInteger();
       int[] expected = {1, 2, 1};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(takeLast.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -408,10 +408,10 @@ public void testPrependInt() {
       Operand<TInt32> prepend = Shapes.prepend(scope, tfshape, 3);
       AtomicInteger index = new AtomicInteger();
       int[] expected = {3, 4, 2};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(prepend.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -434,10 +434,10 @@ public void testPrependLong() {
       Operand<TInt64> prepend = Shapes.prepend(scope, tfshape, 1L);
       AtomicInteger index = new AtomicInteger();
       long[] expected = {1, 4, 2};
-      try (Tensor<TInt64> result =
+      try (TInt64 result =
           session.runner().fetch(prepend.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -465,10 +465,10 @@ public void testPrependShapeTInt32() {
       Operand<TInt32> prepend = Shapes.prepend(scope, tfshape1, tfshape2);
       AtomicInteger index = new AtomicInteger();
       int[] expected = {2, 4, 4, 2};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(prepend.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -496,10 +496,10 @@ public void testPrependShapeTInt64() {
       Operand<TInt64> prepend = Shapes.prepend(scope, tfshape1, tfshape2);
       AtomicInteger index = new AtomicInteger();
       long[] expected = {2, 4, 4, 2};
-      try (Tensor<TInt64> result =
+      try (TInt64 result =
           session.runner().fetch(prepend.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -522,10 +522,10 @@ public void testAppendLong() {
       Operand<TInt64> append = Shapes.append(scope, tfshape, 2L);
       AtomicInteger index = new AtomicInteger();
       long[] expected = {4L, 2L, 2L};
-      try (Tensor<TInt64> result =
+      try (TInt64 result =
           session.runner().fetch(append.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -548,10 +548,10 @@ public void testAppendInt() {
       Operand<TInt32> append = Shapes.append(scope, tfshape, 2);
       AtomicInteger index = new AtomicInteger();
       int[] expected = {4, 2, 2};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(append.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -579,10 +579,10 @@ public void testAppendShapeTInt32() {
       Operand<TInt32> append = Shapes.append(scope, tfshape1, tfshape2);
       AtomicInteger index = new AtomicInteger();
       int[] expected = {4, 2, 2, 4};
-      try (Tensor<TInt32> result =
+      try (TInt32 result =
           session.runner().fetch(append.asOutput()).run().get(0).expect(TInt32.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
@@ -610,10 +610,10 @@ public void testAppendShapeTInt64() {
       Operand<TInt64> append = Shapes.append(scope, tfshape1, tfshape2);
       AtomicInteger index = new AtomicInteger();
       long[] expected = {4, 2, 2, 4};
-      try (Tensor<TInt64> result =
+      try (TInt64 result =
           session.runner().fetch(append.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
         result
-            .data()
+
             .scalars()
             .forEach(
                 s -> {
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ZerosTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ZerosTest.java
index 9600f8b38fc..55dcef5ae3c 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ZerosTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ZerosTest.java
@@ -42,8 +42,8 @@ public void createIntZeros() {
       Scope scope = new Scope(g);
       long[] shape = {2, 2};
       Zeros<TInt32> op = Zeros.create(scope, Constant.vectorOf(scope, shape), TInt32.DTYPE);
-      try (Tensor<TInt32> result = sess.runner().fetch(op).run().get(0).expect(TInt32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(0, s.getInt()));
+      try (TInt32 result = sess.runner().fetch(op).run().get(0).expect(TInt32.DTYPE)) {
+        result.scalars().forEach(s -> assertEquals(0, s.getInt()));
       }
     }
   }
@@ -55,8 +55,8 @@ public void createFloatZeros() {
       Scope scope = new Scope(g);
       long[] shape = {2, 2};
       Zeros<TFloat32> op = Zeros.create(scope, Constant.vectorOf(scope, shape), TFloat32.DTYPE);
-      try (Tensor<TFloat32> result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TFloat32.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(0.0f, s.getFloat(), 0));
+      try (TFloat32 result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TFloat32.DTYPE)) {
+        result.scalars().forEach(s -> assertEquals(0.0f, s.getFloat(), 0));
       }
     }
   }
@@ -68,8 +68,8 @@ public void createDoubleZeros() {
       Scope scope = new Scope(g);
       long[] shape = {2, 2};
       Zeros<TFloat64> op = Zeros.create(scope, Constant.vectorOf(scope, shape), TFloat64.DTYPE);
-      try (Tensor<TFloat64> result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TFloat64.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(0.0f, s.getDouble(), 0));
+      try (TFloat64 result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TFloat64.DTYPE)) {
+        result.scalars().forEach(s -> assertEquals(0.0f, s.getDouble(), 0));
       }
     }
   }
@@ -81,8 +81,8 @@ public void createLongZeros() {
       Scope scope = new Scope(g);
       long[] shape = {2, 2};
       Zeros<TInt64> op = Zeros.create(scope, Constant.vectorOf(scope, shape), TInt64.DTYPE);
-      try (Tensor<TInt64> result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(0L, s.getLong()));
+      try (TInt64 result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TInt64.DTYPE)) {
+        result.scalars().forEach(s -> assertEquals(0L, s.getLong()));
       }
     }
   }
@@ -94,8 +94,8 @@ public void createBooleanZeros() {
       Scope scope = new Scope(g);
       long[] shape = {2, 2};
       Zeros<TBool> op = Zeros.create(scope, Constant.vectorOf(scope, shape), TBool.DTYPE);
-      try (Tensor<TBool> result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TBool.DTYPE)) {
-        result.data().scalars().forEach(s -> assertFalse(s.getBoolean()));
+      try (TBool result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TBool.DTYPE)) {
+        result.scalars().forEach(s -> assertFalse(s.getBoolean()));
       }
    }
   }
@@ -107,8 +107,8 @@ public void createUint8Zeros() {
       Scope scope = new Scope(g);
       long[] shape = {2, 2};
       Zeros<TUint8> op = Zeros.create(scope, Constant.vectorOf(scope, shape), TUint8.DTYPE);
-      try (Tensor<TUint8> result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TUint8.DTYPE)) {
-        result.data().scalars().forEach(s -> assertEquals(0, s.getByte()));
+      try (TUint8 result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TUint8.DTYPE)) {
+        result.scalars().forEach(s -> assertEquals(0, s.getByte()));
       }
     }
   }
@@ -120,8 +120,8 @@ public void createStringZeros() {
       Scope scope = new Scope(g);
       long[] shape = {2, 2};
       Zeros<TString> op = Zeros.create(scope, Constant.vectorOf(scope, shape), TString.DTYPE);
-      try (Tensor<TString> result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TString.DTYPE)) {
-        result.data().scalars().forEach(s -> assertTrue(s.getObject().isEmpty()));
+      try (TString result = sess.runner().fetch(op.asOutput()).run().get(0).expect(TString.DTYPE)) {
+        result.scalars().forEach(s -> assertTrue(s.getObject().isEmpty()));
       }
     }
   }
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 87b24b0da2a..de4dc09035f 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
@@ -27,36 +27,35 @@
 import org.tensorflow.op.math.Sub;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.IntNdArray;
-import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.index.Indices;
-import org.tensorflow.types.family.TNumber;
+import org.tensorflow.tensor.IntTensor;
+import org.tensorflow.types.family.TType;
 
-abstract class NumericTypesTestBase<T extends TNumber & NdArray<U>, U> {
+abstract class NumericTypesTestBase<T extends Tensor<U> & TType, U> {
 
   @Test
   public void initializeTensorsWithZeros() {
     // Allocate a tensor of 32-bits integer of the shape (2, 3, 2)
-    Tensor<T> tensor = allocateTensor(Shape.of(2, 3, 2));
-    NdArray<U> tensorData = tensor.data();
+    T tensor = allocateTensor(Shape.of(2, 3, 2));
 
-    assertEquals(3, tensorData.rank());
-    assertEquals(12, tensorData.size());
+    assertEquals(3, tensor.rank());
+    assertEquals(12, tensor.size());
 
     try (EagerSession session = EagerSession.create()) {
       Ops tf = Ops.create(session);
 
       // Initialize tensor memory with zeros and take a snapshot
-      tensorData.scalars().forEach(scalar -> scalar.setObject(valueOf(0)));
+      tensor.scalars().forEach(scalar -> scalar.setObject(valueOf(0)));
       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)));
+      tensor.scalars().forEach(scalar -> scalar.setObject(valueOf(1)));
       Constant<T> y = tf.constant(tensor);
 
       // Subtract y from x and validate the result
       Sub<T> sub = tf.math.sub(x, y);
-      sub.data().scalars().forEach(scalar ->
+      sub.asTensor().scalars().forEach(scalar ->
           assertEquals(valueOf(-1), scalar.getObject())
       );
     }
@@ -67,22 +66,21 @@ public void genericTest() {
     IntNdArray heapData = NdArrays.vectorOf(0, 1, 2, 3);
 
     // Creates a 2x2 matrix
-    try (Tensor<TInt32> tensor = TInt32.tensorOf(Shape.of(2, 2))) {
-      IntNdArray tensorData = tensor.data();
+    try (IntTensor tensor = TInt32.tensorOf(Shape.of(2, 2))) {
 
       // Copy first 2 values of the vector to the first row of the matrix
-      tensorData.set(heapData.slice(Indices.range(0, 2)), 0);
+      tensor.set(heapData.slice(Indices.range(0, 2)), 0);
 
       // Copy values at an odd position in the vector as the second row of the matrix
-      tensorData.set(heapData.slice(Indices.odd()), 1);
+      tensor.set(heapData.slice(Indices.odd()), 1);
 
-      assertEquals(0, tensorData.getInt(0, 0));
-      assertEquals(1, tensorData.getInt(0, 1));
-      assertEquals(1, tensorData.getInt(1, 0));
-      assertEquals(3, tensorData.getInt(1, 1));
+      assertEquals(0, tensor.getInt(0, 0));
+      assertEquals(1, tensor.getInt(0, 1));
+      assertEquals(1, tensor.getInt(1, 0));
+      assertEquals(3, tensor.getInt(1, 1));
 
       // Read rows of the tensor in reverse order
-      IntNdArray reversedTensorData = tensorData.slice(Indices.all(), Indices.flip());
+      IntNdArray reversedTensorData = tensor.slice(Indices.all(), Indices.flip());
 
       assertEquals(1, reversedTensorData.getInt(0, 0));
       assertEquals(0, reversedTensorData.getInt(0, 1));
@@ -97,14 +95,14 @@ public void genericTest() {
         IntNdArray result = tf.math.pow(x, x).data();
 
         // Validate result by computing the same operation in Java
-        tensorData.scalars().forEachIndexed((coords, s) ->
+        tensor.scalars().forEachIndexed((coords, s) ->
           assertEquals(Math.pow(s.getInt(), s.getInt()), result.getInt(coords), 1e-7f)
         );
       }
     }
   }
 
-  abstract Tensor<T> allocateTensor(Shape shape);
+  abstract T allocateTensor(Shape shape);
 
   abstract U valueOf(Integer value);
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java
index 8681e805e3d..1ef6a24fc8b 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java
@@ -23,7 +23,7 @@
 public class TBfloat16Test extends NumericTypesTestBase<TBfloat16, Float> {
 
   @Override
-  Tensor<TBfloat16> allocateTensor(Shape shape) {
+  TBfloat16 allocateTensor(Shape shape) {
     return TBfloat16.tensorOf(shape);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java
index b72fe6fc01c..b0b2fa908f0 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java
@@ -23,7 +23,7 @@
 public class TFloat16Test extends NumericTypesTestBase<TFloat16, Float> {
 
   @Override
-  Tensor<TFloat16> allocateTensor(Shape shape) {
+  TFloat16 allocateTensor(Shape shape) {
     return TFloat16.tensorOf(shape);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java
index c4b1f6023f3..21ef1586d12 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java
@@ -23,7 +23,7 @@
 public class TFloat32Test extends NumericTypesTestBase<TFloat32, Float> {
 
   @Override
-  Tensor<TFloat32> allocateTensor(Shape shape) {
+  TFloat32 allocateTensor(Shape shape) {
     return TFloat32.tensorOf(shape);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java
index 0e9c8947d0f..cb9de0bea19 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java
@@ -23,7 +23,7 @@
 public class TFloat64Test extends NumericTypesTestBase<TFloat64, Double> {
 
   @Override
-  Tensor<TFloat64> allocateTensor(Shape shape) {
+  TFloat64 allocateTensor(Shape shape) {
     return TFloat64.tensorOf(shape);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java
index c52394bf210..8388c2834b2 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java
@@ -23,7 +23,7 @@
 public class TInt32Test extends NumericTypesTestBase<TInt32, Integer> {
 
   @Override
-  Tensor<TInt32> allocateTensor(Shape shape) {
+  TInt32 allocateTensor(Shape shape) {
     return TInt32.tensorOf(shape);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java
index 261ac546fc5..55e4c7ead87 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java
@@ -23,7 +23,7 @@
 public class TInt64Test extends NumericTypesTestBase<TInt64, Long> {
 
   @Override
-  Tensor<TInt64> allocateTensor(Shape shape) {
+  TInt64 allocateTensor(Shape shape) {
     return TInt64.tensorOf(shape);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java
index 40331543370..ad506498492 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java
@@ -32,25 +32,19 @@ public class TStringTest {
 
   @Test
   public void createScalar() {
-    Tensor<TString> tensor = TString.scalarOf("Pretty vacant");
+    TString tensor = TString.scalarOf("Pretty vacant");
     assertNotNull(tensor);
-
-    TString data = tensor.data();
-    assertNotNull(data);
-    assertEquals(Shape.scalar(), data.shape());
-    assertEquals("Pretty vacant", data.getObject());
+    assertEquals(Shape.scalar(), tensor.shape());
+    assertEquals("Pretty vacant", tensor.getObject());
   }
 
   @Test
   public void createVector() {
-    Tensor<TString> tensor = TString.vectorOf("Pretty", "vacant");
+    TString tensor = TString.vectorOf("Pretty", "vacant");
     assertNotNull(tensor);
-
-    TString data = tensor.data();
-    assertNotNull(data);
-    assertEquals(Shape.of(2), data.shape());
-    assertEquals("Pretty", data.getObject(0));
-    assertEquals("vacant", data.getObject(1));
+    assertEquals(Shape.of(2), tensor.shape());
+    assertEquals("Pretty", tensor.getObject(0));
+    assertEquals("vacant", tensor.getObject(1));
   }
 
   @Test
@@ -61,30 +55,27 @@ public void createCopy() {
         .setObject("New", 1, 0)
         .setObject("York", 1, 1);
 
-    Tensor<TString> tensor = TString.tensorOf(strings);
+    TString tensor = TString.tensorOf(strings);
     assertNotNull(tensor);
-
-    TString data = tensor.data();
-    assertNotNull(data);
     strings.scalars().forEachIndexed((idx, s) ->
-        assertEquals(s.getObject(), data.getObject(idx))
+        assertEquals(s.getObject(), tensor.getObject(idx))
     );
   }
 
   @Test
   public void defaultCharsetIsUtf8() {
-    Tensor<TString> tensor = TString.tensorOf(NdArrays.scalarOfObject(BABY_CHICK));
-    byte[] bytes = tensor.data().asBytes().getObject();
+    TString tensor = TString.tensorOf(NdArrays.scalarOfObject(BABY_CHICK));
+    byte[] bytes = tensor.asBytes().getObject();
     assertArrayEquals(new byte[] { (byte)0xF0, (byte)0x9F, (byte)0x90, (byte)0xA5 }, bytes);
     assertEquals(BABY_CHICK, tensor.data().getObject());
   }
 
   @Test
   public void usingDifferentCharset() {
-    Tensor<TString> tensor = TString.tensorOf(StandardCharsets.UTF_16LE, NdArrays.scalarOfObject(BABY_CHICK));
-    byte[] bytes = tensor.data().asBytes().getObject();
+    TString tensor = TString.tensorOf(StandardCharsets.UTF_16LE, NdArrays.scalarOfObject(BABY_CHICK));
+    byte[] bytes = tensor.asBytes().getObject();
     assertArrayEquals(new byte[] { (byte)0x3D, (byte)0xD8, (byte)0x25, (byte)0xDC }, bytes);
-    assertEquals(BABY_CHICK, tensor.data().using(StandardCharsets.UTF_16LE).getObject());
+    assertEquals(BABY_CHICK, tensor.using(StandardCharsets.UTF_16LE).getObject());
   }
 
   @Test
@@ -94,11 +85,11 @@ public void initializingTensorWithRawBytes() {
     for (int i = 0; i < strings.length; ++i) {
       bytes.setObject(strings[i].getBytes(), i);
     }
-    Tensor<TString> tensor = TString.tensorOfBytes(bytes);
+    TString tensor = TString.tensorOfBytes(bytes);
     assertNotNull(tensor);
     assertEquals(bytes.shape(), tensor.shape());
 
-    NdArray<byte[]> tensorBytes = tensor.data().asBytes();
+    NdArray<byte[]> tensorBytes = tensor.asBytes();
     for (int i = 0; i < strings.length; ++i) {
       assertArrayEquals(bytes.getObject(i), tensorBytes.getObject(i));
     }
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java
index cc83087e018..eb2ddd5bd38 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java
@@ -23,7 +23,7 @@
 public class TUint8Test extends NumericTypesTestBase<TUint8, Byte> {
 
   @Override
-  Tensor<TUint8> allocateTensor(Shape shape) {
+  TUint8 allocateTensor(Shape shape) {
     return TUint8.tensorOf(shape);
   }
 

From e7fd365d256d15fd1c59b102ab611ab44fee44fd Mon Sep 17 00:00:00 2001
From: Karl Lessard <karl.lessard@gmail.com>
Date: Tue, 4 Aug 2020 10:01:18 -0400
Subject: [PATCH 4/4] Delegate NdArray calls on tensors

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

diff --git a/ndarray/src/main/java/org/tensorflow/ndarray/NdArrays.java b/ndarray/src/main/java/org/tensorflow/ndarray/NdArrays.java
index 186d8019888..508e8a3e09e 100644
--- a/ndarray/src/main/java/org/tensorflow/ndarray/NdArrays.java
+++ b/ndarray/src/main/java/org/tensorflow/ndarray/NdArrays.java
@@ -65,7 +65,7 @@ public static ByteNdArray vectorOf(byte... values) {
     if (values == null) {
       throw new IllegalArgumentException("Values cannot be null");
     }
-    return wrap(DataBuffers.of(values, false, false), Shape.of(values.length));
+    return wrap(Shape.of(values.length), DataBuffers.of(values, false, false));
   }
 
   /**
@@ -81,19 +81,19 @@ public static ByteNdArray ofBytes(Shape shape) {
     if (shape == null) {
       throw new IllegalArgumentException("Shape cannot be null");
     }
-    return wrap(DataBuffers.ofBytes(shape.size()), shape);
+    return wrap(shape, DataBuffers.ofBytes(shape.size()));
   }
 
   /**
    * Wraps a buffer in a byte N-dimensional array of a given shape.
    *
-   * @param buffer buffer to wrap
    * @param shape shape of the array
+   * @param buffer buffer to wrap
    * @return new byte N-dimensional array
    * @throws IllegalArgumentException if shape is null, has unknown dimensions or has size bigger
    *                                  in the buffer size
    */
-  public static ByteNdArray wrap(ByteDataBuffer buffer, Shape shape) {
+  public static ByteNdArray wrap(Shape shape, ByteDataBuffer buffer) {
     return ByteDenseNdArray.create(buffer, shape);
   }
 
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 e5791dcc456..0667f0db05b 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
@@ -237,12 +237,12 @@ void RenderFactoryMethods(const OpSpec& op, const Type& op_class,
   writer->EndLine();
   for (const ArgumentSpec& input : op.inputs()) {
     if (input.iterable()) {
-      writer->Append("opBuilder.addInputList(Operands.asOutputs(" +
+      writer->Append("opBuilder.addInputList(Operands.asOutputs(scope, " +
                      input.var().name() + "));");
       writer->EndLine();
     } else {
       writer->Append("opBuilder.addInput(" + input.var().name() +
-                     ".asOutput());");
+                     ".asOutput(scope));");
       writer->EndLine();
     }
   }
@@ -348,8 +348,9 @@ void RenderInterfaceImpl(const OpSpec& op, RenderMode mode,
   if (mode == OPERAND) {
     bool cast2obj = output.type().wildcard();
     Type return_type = Type::Class("Output", "org.tensorflow")
-        .add_parameter(cast2obj ? Type::Interface("Tensor", "org.tensorflow") : output.type());
+        .add_parameter(cast2obj ? Type::Interface("TType", "org.tensorflow.types.family") : output.type());
     Method as_output = Method::Create("asOutput", return_type)
+        .add_argument(Variable::Create("scope", Type::Class("Scope", "org.tensorflow.op")))
         .add_annotation(Annotation::Create("Override"));
     if (cast2obj) {
       as_output.add_annotation(
@@ -366,7 +367,7 @@ void RenderInterfaceImpl(const OpSpec& op, RenderMode mode,
   } else if (mode == LIST_OPERAND) {
     Type operand = Type::Interface("Operand", "org.tensorflow");
     if (output.type().wildcard()) {
-      operand.add_parameter(Type::Interface("Tensor", "org.tensorflow"));
+      operand.add_parameter(Type::Interface("TType", "org.tensorflow.types.family"));
     } else {
       operand.add_parameter(output.type());
     }
@@ -430,7 +431,7 @@ void GenerateOp(const OpSpec& op, const EndpointSpec& endpoint,
   RenderMode mode = DEFAULT;
   if (op.outputs().size() == 1) {
     const ArgumentSpec& output = op.outputs().front();
-    Type operand_type(output.type().wildcard() ? Type::Interface("Tensor", "org.tensorflow")
+    Type operand_type(output.type().wildcard() ? Type::Interface("TType", "org.tensorflow.types.family")
                                                : output.type());
     Type operand_inf(Type::Interface("Operand", "org.tensorflow").add_parameter(operand_type));
     if (output.iterable()) {
diff --git a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc
index 3c981bf8816..7906613569a 100644
--- a/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc
+++ b/tensorflow-core/tensorflow-core-api/src/bazel/op_generator/op_specs.cc
@@ -65,6 +65,13 @@ class TypeResolver {
   std::pair<Type, Type> TypesOf(const OpDef_AttrDef& attr_def,
                                 bool* iterable_out);
 
+  // Returns the highest type family this attribute is part of
+  //
+  // For example, if the attribute is of type 'bool', the base 'TType' family
+  // returned. But if it represents a number, like a float or an integer,
+  // then 'TNumber' (which supersedes 'TType') is returned.
+  Type FamilyOf(const OpDef_AttrDef& attr_def);
+
   // Returns true if the type of this attribute has already been resolved
   bool IsAttributeVisited(const string& attr_name) {
     return visited_attrs_.find(attr_name) != visited_attrs_.cend();
@@ -81,13 +88,12 @@ class TypeResolver {
   std::pair<Type, Type> MakeTypePair(const Type& type) {
     return std::make_pair(type, type);
   }
-  Type NextGeneric() {
+  Type NextGeneric(const Type& typeFamily) {
     char generic_letter = next_generic_letter_++;
     if (next_generic_letter_ > 'Z') {
       next_generic_letter_ = 'A';
     }
-    return Type::Generic(string(1, generic_letter))
-        .add_supertype(Type::Interface("Tensor", "org.tensorflow"));
+    return Type::Generic(string(1, generic_letter)).add_supertype(typeFamily);
   }
 };
 
@@ -156,10 +162,7 @@ std::pair<Type, Type> TypeResolver::TypesOf(const OpDef_AttrDef& attr_def,
                              .add_parameter(Type::Wildcard()));
 
   } else if (attr_type == "type") {
-    Type type = *iterable_out ? Type::Wildcard() : NextGeneric();
-    if (IsRealNumbers(attr_def.allowed_values())) {
-      type.add_supertype(Type::Interface("TNumber", "org.tensorflow.types.family"));
-    }
+    Type type = *iterable_out ? Type::Wildcard() : NextGeneric(FamilyOf(attr_def));
     types = MakeTypePair(type, Type::Enum("DataType", "org.tensorflow"));
 
   } else {
@@ -170,6 +173,14 @@ std::pair<Type, Type> TypeResolver::TypesOf(const OpDef_AttrDef& attr_def,
   return types;
 }
 
+Type TypeResolver::FamilyOf(const OpDef_AttrDef& attr_def) {
+  // TODO (karlllessard): add more type families
+  if (IsRealNumbers(attr_def.allowed_values())) {
+    return Type::Interface("TNumber", "org.tensorflow.types.family");
+  }
+  return Type::Interface("TType", "org.tensorflow.types.family");
+}
+
 string SnakeToCamelCase(const string& str, bool upper = false) {
   string result;
   bool cap = upper;
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java
index 9cc4506b77a..8ac6d565e51 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/BitwiseOps.java
@@ -18,7 +18,6 @@
 package org.tensorflow.op;
 
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.bitwise.BitwiseAnd;
 import org.tensorflow.op.bitwise.BitwiseOr;
 import org.tensorflow.op.bitwise.BitwiseXor;
@@ -66,7 +65,7 @@ public final class BitwiseOps {
    * @param y
    * @return a new instance of BitwiseAnd
    */
-  public <T extends Tensor & TNumber> BitwiseAnd<T> bitwiseAnd(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> BitwiseAnd<T> bitwiseAnd(Operand<T> x, Operand<T> y) {
     return BitwiseAnd.create(scope, x, y);
   }
 
@@ -97,7 +96,7 @@ public <T extends Tensor & TNumber> BitwiseAnd<T> bitwiseAnd(Operand<T> x, Opera
    * @param y
    * @return a new instance of BitwiseOr
    */
-  public <T extends Tensor & TNumber> BitwiseOr<T> bitwiseOr(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> BitwiseOr<T> bitwiseOr(Operand<T> x, Operand<T> y) {
     return BitwiseOr.create(scope, x, y);
   }
 
@@ -128,7 +127,7 @@ public <T extends Tensor & TNumber> BitwiseOr<T> bitwiseOr(Operand<T> x, Operand
    * @param y
    * @return a new instance of BitwiseXor
    */
-  public <T extends Tensor & TNumber> BitwiseXor<T> bitwiseXor(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> BitwiseXor<T> bitwiseXor(Operand<T> x, Operand<T> y) {
     return BitwiseXor.create(scope, x, y);
   }
 
@@ -179,7 +178,7 @@ public <T extends Tensor & TNumber> BitwiseXor<T> bitwiseXor(Operand<T> x, Opera
    * @param x
    * @return a new instance of Invert
    */
-  public <T extends Tensor & TNumber> Invert<T> invert(Operand<T> x) {
+  public <T extends TNumber> Invert<T> invert(Operand<T> x) {
     return Invert.create(scope, x);
   }
 
@@ -221,7 +220,7 @@ public <T extends Tensor & TNumber> Invert<T> invert(Operand<T> x) {
    * @param y
    * @return a new instance of LeftShift
    */
-  public <T extends Tensor & TNumber> LeftShift<T> leftShift(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> LeftShift<T> leftShift(Operand<T> x, Operand<T> y) {
     return LeftShift.create(scope, x, y);
   }
 
@@ -266,7 +265,7 @@ public <T extends Tensor & TNumber> LeftShift<T> leftShift(Operand<T> x, Operand
    * @param y
    * @return a new instance of RightShift
    */
-  public <T extends Tensor & TNumber> RightShift<T> rightShift(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> RightShift<T> rightShift(Operand<T> x, Operand<T> y) {
     return RightShift.create(scope, x, y);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java
index 92f4466f181..16d571a6428 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/DtypesOps.java
@@ -19,11 +19,11 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.dtypes.AsString;
 import org.tensorflow.op.dtypes.Cast;
 import org.tensorflow.op.dtypes.Complex;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code dtypes} operations as {@link Op Op}s
@@ -57,7 +57,7 @@ public final class DtypesOps {
    * @param options carries optional attributes values
    * @return a new instance of AsString
    */
-  public <T extends Tensor> AsString asString(Operand<T> input, AsString.Options... options) {
+  public <T extends TType> AsString asString(Operand<T> input, AsString.Options... options) {
     return AsString.create(scope, input, options);
   }
 
@@ -70,7 +70,7 @@ public <T extends Tensor> AsString asString(Operand<T> input, AsString.Options..
    * @param options carries optional attributes values
    * @return a new instance of Cast
    */
-  public <U extends Tensor, T extends Tensor> Cast<U> cast(Operand<T> x, DataType<U> DstT,
+  public <U extends TType, T extends TType> Cast<U> cast(Operand<T> x, DataType<U> DstT,
       Cast.Options... options) {
     return Cast.create(scope, x, DstT, options);
   }
@@ -98,8 +98,8 @@ public <U extends Tensor, T extends Tensor> Cast<U> cast(Operand<T> x, DataType<
    * @param Tout
    * @return a new instance of Complex
    */
-  public <U extends Tensor, T extends Tensor & TNumber> Complex<U> complex(Operand<T> real,
-      Operand<T> imag, DataType<U> Tout) {
+  public <U extends TType, T extends TNumber> Complex<U> complex(Operand<T> real, Operand<T> imag,
+      DataType<U> Tout) {
     return Complex.create(scope, real, imag, Tout);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java
index eddb078fdce..9ea7a898d60 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ImageOps.java
@@ -20,7 +20,6 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.image.AdjustContrast;
 import org.tensorflow.op.image.AdjustHue;
 import org.tensorflow.op.image.AdjustSaturation;
@@ -58,6 +57,7 @@
 import org.tensorflow.types.TString;
 import org.tensorflow.types.TUint8;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code image} operations as {@link Op Op}s
@@ -89,7 +89,7 @@ public final class ImageOps {
    * @param contrastFactor A float multiplier for adjusting contrast.
    * @return a new instance of AdjustContrast
    */
-  public <T extends Tensor & TNumber> AdjustContrast<T> adjustContrast(Operand<T> images,
+  public <T extends TNumber> AdjustContrast<T> adjustContrast(Operand<T> images,
       Operand<TFloat32> contrastFactor) {
     return AdjustContrast.create(scope, images, contrastFactor);
   }
@@ -109,8 +109,7 @@ public <T extends Tensor & TNumber> AdjustContrast<T> adjustContrast(Operand<T>
    * @param delta A float delta to add to the hue.
    * @return a new instance of AdjustHue
    */
-  public <T extends Tensor & TNumber> AdjustHue<T> adjustHue(Operand<T> images,
-      Operand<TFloat32> delta) {
+  public <T extends TNumber> AdjustHue<T> adjustHue(Operand<T> images, Operand<TFloat32> delta) {
     return AdjustHue.create(scope, images, delta);
   }
 
@@ -129,7 +128,7 @@ public <T extends Tensor & TNumber> AdjustHue<T> adjustHue(Operand<T> images,
    * @param scale A float scale to add to the saturation.
    * @return a new instance of AdjustSaturation
    */
-  public <T extends Tensor & TNumber> AdjustSaturation<T> adjustSaturation(Operand<T> images,
+  public <T extends TNumber> AdjustSaturation<T> adjustSaturation(Operand<T> images,
       Operand<TFloat32> scale) {
     return AdjustSaturation.create(scope, images, scale);
   }
@@ -213,9 +212,8 @@ public CombinedNonMaxSuppression combinedNonMaxSuppression(Operand<TFloat32> box
    * @param options carries optional attributes values
    * @return a new instance of CropAndResize
    */
-  public <T extends Tensor & TNumber> CropAndResize cropAndResize(Operand<T> image,
-      Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> cropSize,
-      CropAndResize.Options... options) {
+  public <T extends TNumber> CropAndResize cropAndResize(Operand<T> image, Operand<TFloat32> boxes,
+      Operand<TInt32> boxInd, Operand<TInt32> cropSize, CropAndResize.Options... options) {
     return CropAndResize.create(scope, image, boxes, boxInd, cropSize, options);
   }
 
@@ -240,8 +238,8 @@ public <T extends Tensor & TNumber> CropAndResize cropAndResize(Operand<T> image
    * @param options carries optional attributes values
    * @return a new instance of CropAndResizeGradBoxes
    */
-  public <T extends Tensor & TNumber> CropAndResizeGradBoxes cropAndResizeGradBoxes(
-      Operand<TFloat32> grads, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd,
+  public <T extends TNumber> CropAndResizeGradBoxes cropAndResizeGradBoxes(Operand<TFloat32> grads,
+      Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd,
       CropAndResizeGradBoxes.Options... options) {
     return CropAndResizeGradBoxes.create(scope, grads, image, boxes, boxInd, options);
   }
@@ -270,7 +268,7 @@ public <T extends Tensor & TNumber> CropAndResizeGradBoxes cropAndResizeGradBoxe
    * @param options carries optional attributes values
    * @return a new instance of CropAndResizeGradImage
    */
-  public <T extends Tensor & TNumber> CropAndResizeGradImage<T> cropAndResizeGradImage(
+  public <T extends TNumber> CropAndResizeGradImage<T> cropAndResizeGradImage(
       Operand<TFloat32> grads, Operand<TFloat32> boxes, Operand<TInt32> boxInd,
       Operand<TInt32> imageSize, DataType<T> T, CropAndResizeGradImage.Options... options) {
     return CropAndResizeGradImage.create(scope, grads, boxes, boxInd, imageSize, T, options);
@@ -463,8 +461,8 @@ public DecodePng<TUint8> decodePng(Operand<TString> contents, DecodePng.Options.
    * @param options carries optional attributes values
    * @return a new instance of DecodePng
    */
-  public <T extends Tensor & TNumber> DecodePng<T> decodePng(Operand<TString> contents,
-      DataType<T> dtype, DecodePng.Options... options) {
+  public <T extends TNumber> DecodePng<T> decodePng(Operand<TString> contents, DataType<T> dtype,
+      DecodePng.Options... options) {
     return DecodePng.create(scope, contents, dtype, options);
   }
 
@@ -490,7 +488,7 @@ public <T extends Tensor & TNumber> DecodePng<T> decodePng(Operand<TString> cont
    * @param colors 2-D. A list of RGBA colors to cycle through for the boxes.
    * @return a new instance of DrawBoundingBoxes
    */
-  public <T extends Tensor & TNumber> DrawBoundingBoxes<T> drawBoundingBoxes(Operand<T> images,
+  public <T extends TNumber> DrawBoundingBoxes<T> drawBoundingBoxes(Operand<T> images,
       Operand<TFloat32> boxes, Operand<TFloat32> colors) {
     return DrawBoundingBoxes.create(scope, images, boxes, colors);
   }
@@ -574,8 +572,7 @@ public EncodeJpegVariableQuality encodeJpegVariableQuality(Operand<TUint8> image
    * @param options carries optional attributes values
    * @return a new instance of EncodePng
    */
-  public <T extends Tensor & TNumber> EncodePng encodePng(Operand<T> image,
-      EncodePng.Options... options) {
+  public <T extends TNumber> EncodePng encodePng(Operand<T> image, EncodePng.Options... options) {
     return EncodePng.create(scope, image, options);
   }
 
@@ -640,7 +637,7 @@ public ExtractGlimpse extractGlimpse(Operand<TFloat32> input, Operand<TInt32> si
    * @param padding The type of padding algorithm to use.
    * @return a new instance of ExtractImagePatches
    */
-  public <T extends Tensor> ExtractImagePatches<T> extractImagePatches(Operand<T> images,
+  public <T extends TType> ExtractImagePatches<T> extractImagePatches(Operand<T> images,
       List<Long> ksizes, List<Long> strides, List<Long> rates, String padding) {
     return ExtractImagePatches.create(scope, images, ksizes, strides, rates, padding);
   }
@@ -669,8 +666,8 @@ public ExtractJpegShape<TInt32> extractJpegShape(Operand<TString> contents) {
    *  Defaults to int32.
    * @return a new instance of ExtractJpegShape
    */
-  public <T extends Tensor & TNumber> ExtractJpegShape<T> extractJpegShape(
-      Operand<TString> contents, DataType<T> outputType) {
+  public <T extends TNumber> ExtractJpegShape<T> extractJpegShape(Operand<TString> contents,
+      DataType<T> outputType) {
     return ExtractJpegShape.create(scope, contents, outputType);
   }
 
@@ -687,7 +684,7 @@ public <T extends Tensor & TNumber> ExtractJpegShape<T> extractJpegShape(
    * @param images 1-D or higher rank. HSV data to convert. Last dimension must be size 3.
    * @return a new instance of HsvToRgb
    */
-  public <T extends Tensor & TNumber> HsvToRgb<T> hsvToRgb(Operand<T> images) {
+  public <T extends TNumber> HsvToRgb<T> hsvToRgb(Operand<T> images) {
     return HsvToRgb.create(scope, images);
   }
 
@@ -733,7 +730,7 @@ public <T extends Tensor & TNumber> HsvToRgb<T> hsvToRgb(Operand<T> images) {
    * @param options carries optional attributes values
    * @return a new instance of NonMaxSuppression
    */
-  public <T extends Tensor & TNumber> NonMaxSuppression<T> nonMaxSuppression(Operand<T> boxes,
+  public <T extends TNumber> NonMaxSuppression<T> nonMaxSuppression(Operand<T> boxes,
       Operand<T> scores, Operand<TInt32> maxOutputSize, Operand<T> iouThreshold,
       Operand<T> scoreThreshold, Operand<T> softNmsSigma, NonMaxSuppression.Options... options) {
     return NonMaxSuppression.create(scope, boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, options);
@@ -789,7 +786,7 @@ public NonMaxSuppressionWithOverlaps nonMaxSuppressionWithOverlaps(Operand<TFloa
    * @param options carries optional attributes values
    * @return a new instance of QuantizedResizeBilinear
    */
-  public <T extends Tensor> QuantizedResizeBilinear<T> quantizedResizeBilinear(Operand<T> images,
+  public <T extends TType> QuantizedResizeBilinear<T> quantizedResizeBilinear(Operand<T> images,
       Operand<TInt32> size, Operand<TFloat32> min, Operand<TFloat32> max,
       QuantizedResizeBilinear.Options... options) {
     return QuantizedResizeBilinear.create(scope, images, size, min, max, options);
@@ -811,8 +808,8 @@ public <T extends Tensor> QuantizedResizeBilinear<T> quantizedResizeBilinear(Ope
    * @param options carries optional attributes values
    * @return a new instance of RandomCrop
    */
-  public <T extends Tensor & TNumber> RandomCrop<T> randomCrop(Operand<T> image,
-      Operand<TInt64> size, RandomCrop.Options... options) {
+  public <T extends TNumber> RandomCrop<T> randomCrop(Operand<T> image, Operand<TInt64> size,
+      RandomCrop.Options... options) {
     return RandomCrop.create(scope, image, size, options);
   }
 
@@ -837,7 +834,7 @@ public <T extends Tensor & TNumber> RandomCrop<T> randomCrop(Operand<T> image,
    * @param options carries optional attributes values
    * @return a new instance of ResizeArea
    */
-  public <T extends Tensor & TNumber> ResizeArea resizeArea(Operand<T> images, Operand<TInt32> size,
+  public <T extends TNumber> ResizeArea resizeArea(Operand<T> images, Operand<TInt32> size,
       ResizeArea.Options... options) {
     return ResizeArea.create(scope, images, size, options);
   }
@@ -853,8 +850,8 @@ public <T extends Tensor & TNumber> ResizeArea resizeArea(Operand<T> images, Ope
    * @param options carries optional attributes values
    * @return a new instance of ResizeBicubic
    */
-  public <T extends Tensor & TNumber> ResizeBicubic resizeBicubic(Operand<T> images,
-      Operand<TInt32> size, ResizeBicubic.Options... options) {
+  public <T extends TNumber> ResizeBicubic resizeBicubic(Operand<T> images, Operand<TInt32> size,
+      ResizeBicubic.Options... options) {
     return ResizeBicubic.create(scope, images, size, options);
   }
 
@@ -869,8 +866,8 @@ public <T extends Tensor & TNumber> ResizeBicubic resizeBicubic(Operand<T> image
    * @param options carries optional attributes values
    * @return a new instance of ResizeBilinear
    */
-  public <T extends Tensor & TNumber> ResizeBilinear resizeBilinear(Operand<T> images,
-      Operand<TInt32> size, ResizeBilinear.Options... options) {
+  public <T extends TNumber> ResizeBilinear resizeBilinear(Operand<T> images, Operand<TInt32> size,
+      ResizeBilinear.Options... options) {
     return ResizeBilinear.create(scope, images, size, options);
   }
 
@@ -884,8 +881,8 @@ public <T extends Tensor & TNumber> ResizeBilinear resizeBilinear(Operand<T> ima
    * @param options carries optional attributes values
    * @return a new instance of ResizeNearestNeighbor
    */
-  public <T extends Tensor & TNumber> ResizeNearestNeighbor<T> resizeNearestNeighbor(
-      Operand<T> images, Operand<TInt32> size, ResizeNearestNeighbor.Options... options) {
+  public <T extends TNumber> ResizeNearestNeighbor<T> resizeNearestNeighbor(Operand<T> images,
+      Operand<TInt32> size, ResizeNearestNeighbor.Options... options) {
     return ResizeNearestNeighbor.create(scope, images, size, options);
   }
 
@@ -915,7 +912,7 @@ public <T extends Tensor & TNumber> ResizeNearestNeighbor<T> resizeNearestNeighb
    * @param images 1-D or higher rank. RGB data to convert. Last dimension must be size 3.
    * @return a new instance of RgbToHsv
    */
-  public <T extends Tensor & TNumber> RgbToHsv<T> rgbToHsv(Operand<T> images) {
+  public <T extends TNumber> RgbToHsv<T> rgbToHsv(Operand<T> images) {
     return RgbToHsv.create(scope, images);
   }
 
@@ -970,7 +967,7 @@ public <T extends Tensor & TNumber> RgbToHsv<T> rgbToHsv(Operand<T> images) {
    * @param options carries optional attributes values
    * @return a new instance of SampleDistortedBoundingBox
    */
-  public <T extends Tensor & TNumber> SampleDistortedBoundingBox<T> sampleDistortedBoundingBox(
+  public <T extends TNumber> SampleDistortedBoundingBox<T> sampleDistortedBoundingBox(
       Operand<T> imageSize, Operand<TFloat32> boundingBoxes, Operand<TFloat32> minObjectCovered,
       SampleDistortedBoundingBox.Options... options) {
     return SampleDistortedBoundingBox.create(scope, imageSize, boundingBoxes, minObjectCovered, options);
@@ -985,7 +982,7 @@ public <T extends Tensor & TNumber> SampleDistortedBoundingBox<T> sampleDistorte
    * @param options carries optional attributes values
    * @return a new instance of ScaleAndTranslate
    */
-  public <T extends Tensor & TNumber> ScaleAndTranslate scaleAndTranslate(Operand<T> images,
+  public <T extends TNumber> ScaleAndTranslate scaleAndTranslate(Operand<T> images,
       Operand<TInt32> size, Operand<TFloat32> scale, Operand<TFloat32> translation,
       ScaleAndTranslate.Options... options) {
     return ScaleAndTranslate.create(scope, images, size, scale, translation, options);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java
index e6e672fd266..872533472d9 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/IoOps.java
@@ -20,7 +20,6 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.io.DecodeBase64;
 import org.tensorflow.op.io.DecodeCompressed;
@@ -73,6 +72,7 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code io} operations as {@link Op Op}s
@@ -167,9 +167,8 @@ public DecodeJsonExample decodeJsonExample(Operand<TString> jsonExamples) {
    * @param options carries optional attributes values
    * @return a new instance of DecodePaddedRaw
    */
-  public <T extends Tensor & TNumber> DecodePaddedRaw<T> decodePaddedRaw(
-      Operand<TString> inputBytes, Operand<TInt32> fixedLength, DataType<T> outType,
-      DecodePaddedRaw.Options... options) {
+  public <T extends TNumber> DecodePaddedRaw<T> decodePaddedRaw(Operand<TString> inputBytes,
+      Operand<TInt32> fixedLength, DataType<T> outType, DecodePaddedRaw.Options... options) {
     return DecodePaddedRaw.create(scope, inputBytes, fixedLength, outType, options);
   }
 
@@ -182,7 +181,7 @@ public <T extends Tensor & TNumber> DecodePaddedRaw<T> decodePaddedRaw(
    * @param options carries optional attributes values
    * @return a new instance of DecodeRaw
    */
-  public <T extends Tensor> DecodeRaw<T> decodeRaw(Operand<TString> bytes, DataType<T> outType,
+  public <T extends TType> DecodeRaw<T> decodeRaw(Operand<TString> bytes, DataType<T> outType,
       DecodeRaw.Options... options) {
     return DecodeRaw.create(scope, bytes, outType, options);
   }
@@ -238,7 +237,7 @@ public <T extends Tensor> DecodeRaw<T> decodeRaw(Operand<TString> bytes, DataTyp
    * @param dtype The `dtype` of the serialized `SparseTensor` objects.
    * @return a new instance of DeserializeManySparse
    */
-  public <T extends Tensor> DeserializeManySparse<T> deserializeManySparse(
+  public <T extends TType> DeserializeManySparse<T> deserializeManySparse(
       Operand<TString> serializedSparse, DataType<T> dtype) {
     return DeserializeManySparse.create(scope, serializedSparse, dtype);
   }
@@ -566,7 +565,7 @@ public ParseSingleSequenceExample parseSingleSequenceExample(Operand<TString> se
    *  type of the serialized tensor and no implicit conversion will take place.
    * @return a new instance of ParseTensor
    */
-  public <T extends Tensor> ParseTensor<T> parseTensor(Operand<TString> serialized,
+  public <T extends TType> ParseTensor<T> parseTensor(Operand<TString> serialized,
       DataType<T> outType) {
     return ParseTensor.create(scope, serialized, outType);
   }
@@ -889,7 +888,7 @@ public ReaderSerializeState readerSerializeState(Operand<?> readerHandle) {
    * @param sparseShape 1-D.  The `shape` of the minibatch `SparseTensor`.
    * @return a new instance of SerializeManySparse
    */
-  public <T extends Tensor> SerializeManySparse<TString> serializeManySparse(
+  public <T extends TType> SerializeManySparse<TString> serializeManySparse(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return SerializeManySparse.create(scope, sparseIndices, sparseValues, sparseShape);
   }
@@ -913,7 +912,7 @@ public <T extends Tensor> SerializeManySparse<TString> serializeManySparse(
    *  (default) and `variant`.
    * @return a new instance of SerializeManySparse
    */
-  public <U extends Tensor, T extends Tensor> SerializeManySparse<U> serializeManySparse(
+  public <U extends TType, T extends TType> SerializeManySparse<U> serializeManySparse(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       DataType<U> outType) {
     return SerializeManySparse.create(scope, sparseIndices, sparseValues, sparseShape, outType);
@@ -928,7 +927,7 @@ public <U extends Tensor, T extends Tensor> SerializeManySparse<U> serializeMany
    * @param sparseShape 1-D.  The `shape` of the `SparseTensor`.
    * @return a new instance of SerializeSparse
    */
-  public <T extends Tensor> SerializeSparse<TString> serializeSparse(Operand<TInt64> sparseIndices,
+  public <T extends TType> SerializeSparse<TString> serializeSparse(Operand<TInt64> sparseIndices,
       Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return SerializeSparse.create(scope, sparseIndices, sparseValues, sparseShape);
   }
@@ -944,7 +943,7 @@ public <T extends Tensor> SerializeSparse<TString> serializeSparse(Operand<TInt6
    *  (default) and `variant`.
    * @return a new instance of SerializeSparse
    */
-  public <U extends Tensor, T extends Tensor> SerializeSparse<U> serializeSparse(
+  public <U extends TType, T extends TType> SerializeSparse<U> serializeSparse(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       DataType<U> outType) {
     return SerializeSparse.create(scope, sparseIndices, sparseValues, sparseShape, outType);
@@ -956,7 +955,7 @@ public <U extends Tensor, T extends Tensor> SerializeSparse<U> serializeSparse(
    * @param tensor A Tensor of type `T`.
    * @return a new instance of SerializeTensor
    */
-  public <T extends Tensor> SerializeTensor serializeTensor(Operand<T> tensor) {
+  public <T extends TType> SerializeTensor serializeTensor(Operand<T> tensor) {
     return SerializeTensor.create(scope, tensor);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java
index 3b843bef341..9c82306e539 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/LinalgOps.java
@@ -19,7 +19,6 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.linalg.BandPart;
 import org.tensorflow.op.linalg.BatchCholesky;
 import org.tensorflow.op.linalg.BatchCholeskyGrad;
@@ -69,6 +68,7 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code linalg} operations as {@link Op Op}s
@@ -130,7 +130,7 @@ public final class LinalgOps {
    *  entire upper triangle.
    * @return a new instance of BandPart
    */
-  public <T extends Tensor, U extends Tensor & TNumber> BandPart<T> bandPart(Operand<T> input,
+  public <T extends TType, U extends TNumber> BandPart<T> bandPart(Operand<T> input,
       Operand<U> numLower, Operand<U> numUpper) {
     return BandPart.create(scope, input, numLower, numUpper);
   }
@@ -141,7 +141,7 @@ public <T extends Tensor, U extends Tensor & TNumber> BandPart<T> bandPart(Opera
    * @param input
    * @return a new instance of BatchCholesky
    */
-  public <T extends Tensor & TNumber> BatchCholesky<T> batchCholesky(Operand<T> input) {
+  public <T extends TNumber> BatchCholesky<T> batchCholesky(Operand<T> input) {
     return BatchCholesky.create(scope, input);
   }
 
@@ -152,8 +152,7 @@ public <T extends Tensor & TNumber> BatchCholesky<T> batchCholesky(Operand<T> in
    * @param grad
    * @return a new instance of BatchCholeskyGrad
    */
-  public <T extends Tensor & TNumber> BatchCholeskyGrad<T> batchCholeskyGrad(Operand<T> l,
-      Operand<T> grad) {
+  public <T extends TNumber> BatchCholeskyGrad<T> batchCholeskyGrad(Operand<T> l, Operand<T> grad) {
     return BatchCholeskyGrad.create(scope, l, grad);
   }
 
@@ -165,7 +164,7 @@ public <T extends Tensor & TNumber> BatchCholeskyGrad<T> batchCholeskyGrad(Opera
    * @param numUpper
    * @return a new instance of BatchMatrixBandPart
    */
-  public <T extends Tensor> BatchMatrixBandPart<T> batchMatrixBandPart(Operand<T> input,
+  public <T extends TType> BatchMatrixBandPart<T> batchMatrixBandPart(Operand<T> input,
       Operand<TInt64> numLower, Operand<TInt64> numUpper) {
     return BatchMatrixBandPart.create(scope, input, numLower, numUpper);
   }
@@ -176,7 +175,7 @@ public <T extends Tensor> BatchMatrixBandPart<T> batchMatrixBandPart(Operand<T>
    * @param input
    * @return a new instance of BatchMatrixDeterminant
    */
-  public <T extends Tensor> BatchMatrixDeterminant<T> batchMatrixDeterminant(Operand<T> input) {
+  public <T extends TType> BatchMatrixDeterminant<T> batchMatrixDeterminant(Operand<T> input) {
     return BatchMatrixDeterminant.create(scope, input);
   }
 
@@ -186,7 +185,7 @@ public <T extends Tensor> BatchMatrixDeterminant<T> batchMatrixDeterminant(Opera
    * @param diagonal
    * @return a new instance of BatchMatrixDiag
    */
-  public <T extends Tensor> BatchMatrixDiag<T> batchMatrixDiag(Operand<T> diagonal) {
+  public <T extends TType> BatchMatrixDiag<T> batchMatrixDiag(Operand<T> diagonal) {
     return BatchMatrixDiag.create(scope, diagonal);
   }
 
@@ -196,7 +195,7 @@ public <T extends Tensor> BatchMatrixDiag<T> batchMatrixDiag(Operand<T> diagonal
    * @param input
    * @return a new instance of BatchMatrixDiagPart
    */
-  public <T extends Tensor> BatchMatrixDiagPart<T> batchMatrixDiagPart(Operand<T> input) {
+  public <T extends TType> BatchMatrixDiagPart<T> batchMatrixDiagPart(Operand<T> input) {
     return BatchMatrixDiagPart.create(scope, input);
   }
 
@@ -207,7 +206,7 @@ public <T extends Tensor> BatchMatrixDiagPart<T> batchMatrixDiagPart(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixInverse
    */
-  public <T extends Tensor & TNumber> BatchMatrixInverse<T> batchMatrixInverse(Operand<T> input,
+  public <T extends TNumber> BatchMatrixInverse<T> batchMatrixInverse(Operand<T> input,
       BatchMatrixInverse.Options... options) {
     return BatchMatrixInverse.create(scope, input, options);
   }
@@ -219,7 +218,7 @@ public <T extends Tensor & TNumber> BatchMatrixInverse<T> batchMatrixInverse(Ope
    * @param diagonal
    * @return a new instance of BatchMatrixSetDiag
    */
-  public <T extends Tensor> BatchMatrixSetDiag<T> batchMatrixSetDiag(Operand<T> input,
+  public <T extends TType> BatchMatrixSetDiag<T> batchMatrixSetDiag(Operand<T> input,
       Operand<T> diagonal) {
     return BatchMatrixSetDiag.create(scope, input, diagonal);
   }
@@ -232,8 +231,8 @@ public <T extends Tensor> BatchMatrixSetDiag<T> batchMatrixSetDiag(Operand<T> in
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixSolve
    */
-  public <T extends Tensor & TNumber> BatchMatrixSolve<T> batchMatrixSolve(Operand<T> matrix,
-      Operand<T> rhs, BatchMatrixSolve.Options... options) {
+  public <T extends TNumber> BatchMatrixSolve<T> batchMatrixSolve(Operand<T> matrix, Operand<T> rhs,
+      BatchMatrixSolve.Options... options) {
     return BatchMatrixSolve.create(scope, matrix, rhs, options);
   }
 
@@ -246,7 +245,7 @@ public <T extends Tensor & TNumber> BatchMatrixSolve<T> batchMatrixSolve(Operand
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixSolveLs
    */
-  public <T extends Tensor & TNumber> BatchMatrixSolveLs<T> batchMatrixSolveLs(Operand<T> matrix,
+  public <T extends TNumber> BatchMatrixSolveLs<T> batchMatrixSolveLs(Operand<T> matrix,
       Operand<T> rhs, Operand<TFloat64> l2Regularizer, BatchMatrixSolveLs.Options... options) {
     return BatchMatrixSolveLs.create(scope, matrix, rhs, l2Regularizer, options);
   }
@@ -259,7 +258,7 @@ public <T extends Tensor & TNumber> BatchMatrixSolveLs<T> batchMatrixSolveLs(Ope
    * @param options carries optional attributes values
    * @return a new instance of BatchMatrixTriangularSolve
    */
-  public <T extends Tensor & TNumber> BatchMatrixTriangularSolve<T> batchMatrixTriangularSolve(
+  public <T extends TNumber> BatchMatrixTriangularSolve<T> batchMatrixTriangularSolve(
       Operand<T> matrix, Operand<T> rhs, BatchMatrixTriangularSolve.Options... options) {
     return BatchMatrixTriangularSolve.create(scope, matrix, rhs, options);
   }
@@ -271,7 +270,7 @@ public <T extends Tensor & TNumber> BatchMatrixTriangularSolve<T> batchMatrixTri
    * @param options carries optional attributes values
    * @return a new instance of BatchSelfAdjointEig
    */
-  public <T extends Tensor & TNumber> BatchSelfAdjointEig<T> batchSelfAdjointEig(Operand<T> input,
+  public <T extends TNumber> BatchSelfAdjointEig<T> batchSelfAdjointEig(Operand<T> input,
       BatchSelfAdjointEig.Options... options) {
     return BatchSelfAdjointEig.create(scope, input, options);
   }
@@ -283,7 +282,7 @@ public <T extends Tensor & TNumber> BatchSelfAdjointEig<T> batchSelfAdjointEig(O
    * @param options carries optional attributes values
    * @return a new instance of BatchSvd
    */
-  public <T extends Tensor> BatchSvd<T> batchSvd(Operand<T> input, BatchSvd.Options... options) {
+  public <T extends TType> BatchSvd<T> batchSvd(Operand<T> input, BatchSvd.Options... options) {
     return BatchSvd.create(scope, input, options);
   }
 
@@ -308,7 +307,7 @@ public <T extends Tensor> BatchSvd<T> batchSvd(Operand<T> input, BatchSvd.Option
    * @param input Shape is `[..., M, M]`.
    * @return a new instance of Cholesky
    */
-  public <T extends Tensor> Cholesky<T> cholesky(Operand<T> input) {
+  public <T extends TType> Cholesky<T> cholesky(Operand<T> input) {
     return Cholesky.create(scope, input);
   }
 
@@ -327,7 +326,7 @@ public <T extends Tensor> Cholesky<T> cholesky(Operand<T> input) {
    *  this tensor.
    * @return a new instance of CholeskyGrad
    */
-  public <T extends Tensor & TNumber> CholeskyGrad<T> choleskyGrad(Operand<T> l, Operand<T> grad) {
+  public <T extends TNumber> CholeskyGrad<T> choleskyGrad(Operand<T> l, Operand<T> grad) {
     return CholeskyGrad.create(scope, l, grad);
   }
 
@@ -343,8 +342,8 @@ public <T extends Tensor & TNumber> CholeskyGrad<T> choleskyGrad(Operand<T> l, O
    * @param perm
    * @return a new instance of ConjugateTranspose
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ConjugateTranspose<T> conjugateTranspose(
-      Operand<T> x, Operand<U> perm) {
+  public <T extends TType, U extends TNumber> ConjugateTranspose<T> conjugateTranspose(Operand<T> x,
+      Operand<U> perm) {
     return ConjugateTranspose.create(scope, x, perm);
   }
 
@@ -360,7 +359,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ConjugateTranspose<T> conj
    * @param b Another tensor, of same type and shape as `a`.
    * @return a new instance of Cross
    */
-  public <T extends Tensor & TNumber> Cross<T> cross(Operand<T> a, Operand<T> b) {
+  public <T extends TNumber> Cross<T> cross(Operand<T> a, Operand<T> b) {
     return Cross.create(scope, a, b);
   }
 
@@ -375,7 +374,7 @@ public <T extends Tensor & TNumber> Cross<T> cross(Operand<T> a, Operand<T> b) {
    * @param input Shape is `[..., M, M]`.
    * @return a new instance of Det
    */
-  public <T extends Tensor> Det<T> det(Operand<T> input) {
+  public <T extends TType> Det<T> det(Operand<T> input) {
     return Det.create(scope, input);
   }
 
@@ -399,7 +398,7 @@ public <T extends Tensor> Det<T> det(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of Eig
    */
-  public <U extends Tensor, T extends Tensor> Eig<U> eig(Operand<T> input, DataType<U> Tout,
+  public <U extends TType, T extends TType> Eig<U> eig(Operand<T> input, DataType<U> Tout,
       Eig.Options... options) {
     return Eig.create(scope, input, Tout, options);
   }
@@ -487,7 +486,7 @@ public <U extends Tensor, T extends Tensor> Eig<U> eig(Operand<T> input, DataTyp
    * @param equation String describing the Einstein Summation operation; in the format of np.einsum.
    * @return a new instance of Einsum
    */
-  public <T extends Tensor> Einsum<T> einsum(Iterable<Operand<T>> inputs, String equation) {
+  public <T extends TType> Einsum<T> einsum(Iterable<Operand<T>> inputs, String equation) {
     return Einsum.create(scope, inputs, equation);
   }
 
@@ -506,8 +505,8 @@ public <T extends Tensor> Einsum<T> einsum(Iterable<Operand<T>> inputs, String e
    * @param options carries optional attributes values
    * @return a new instance of EuclideanNorm
    */
-  public <T extends Tensor, U extends Tensor & TNumber> EuclideanNorm<T> euclideanNorm(
-      Operand<T> input, Operand<U> axis, EuclideanNorm.Options... options) {
+  public <T extends TType, U extends TNumber> EuclideanNorm<T> euclideanNorm(Operand<T> input,
+      Operand<U> axis, EuclideanNorm.Options... options) {
     return EuclideanNorm.create(scope, input, axis, options);
   }
 
@@ -531,7 +530,7 @@ public <T extends Tensor, U extends Tensor & TNumber> EuclideanNorm<T> euclidean
    * @param options carries optional attributes values
    * @return a new instance of Inv
    */
-  public <T extends Tensor> Inv<T> inv(Operand<T> input, Inv.Options... options) {
+  public <T extends TType> Inv<T> inv(Operand<T> input, Inv.Options... options) {
     return Inv.create(scope, input, options);
   }
 
@@ -621,7 +620,7 @@ public LoadAndRemapMatrix loadAndRemapMatrix(Operand<TString> ckptPath,
    * @param input Shape is `[N, M, M]`.
    * @return a new instance of LogMatrixDeterminant
    */
-  public <T extends Tensor> LogMatrixDeterminant<T> logMatrixDeterminant(Operand<T> input) {
+  public <T extends TType> LogMatrixDeterminant<T> logMatrixDeterminant(Operand<T> input) {
     return LogMatrixDeterminant.create(scope, input);
   }
 
@@ -652,7 +651,7 @@ public <T extends Tensor> LogMatrixDeterminant<T> logMatrixDeterminant(Operand<T
    *  size `[M, M]`.
    * @return a new instance of Lu
    */
-  public <T extends Tensor> Lu<T, TInt32> lu(Operand<T> input) {
+  public <T extends TType> Lu<T, TInt32> lu(Operand<T> input) {
     return Lu.create(scope, input);
   }
 
@@ -684,7 +683,7 @@ public <T extends Tensor> Lu<T, TInt32> lu(Operand<T> input) {
    * @param outputIdxType
    * @return a new instance of Lu
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Lu<T, U> lu(Operand<T> input,
+  public <T extends TType, U extends TNumber> Lu<T, U> lu(Operand<T> input,
       DataType<U> outputIdxType) {
     return Lu.create(scope, input, outputIdxType);
   }
@@ -706,8 +705,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Lu<T, U> lu(Operand<T> inp
    * @param options carries optional attributes values
    * @return a new instance of MatMul
    */
-  public <T extends Tensor> MatMul<T> matMul(Operand<T> a, Operand<T> b,
-      MatMul.Options... options) {
+  public <T extends TType> MatMul<T> matMul(Operand<T> a, Operand<T> b, MatMul.Options... options) {
     return MatMul.create(scope, a, b, options);
   }
 
@@ -814,7 +812,7 @@ public <T extends Tensor> MatMul<T> matMul(Operand<T> a, Operand<T> b,
    *  Default is 0.
    * @return a new instance of MatrixDiag
    */
-  public <T extends Tensor> MatrixDiag<T> matrixDiag(Operand<T> diagonal, Operand<TInt32> k,
+  public <T extends TType> MatrixDiag<T> matrixDiag(Operand<T> diagonal, Operand<TInt32> k,
       Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue) {
     return MatrixDiag.create(scope, diagonal, k, numRows, numCols, paddingValue);
   }
@@ -898,7 +896,7 @@ public <T extends Tensor> MatrixDiag<T> matrixDiag(Operand<T> diagonal, Operand<
    *  Default is 0.
    * @return a new instance of MatrixDiagPart
    */
-  public <T extends Tensor> MatrixDiagPart<T> matrixDiagPart(Operand<T> input, Operand<TInt32> k,
+  public <T extends TType> MatrixDiagPart<T> matrixDiagPart(Operand<T> input, Operand<TInt32> k,
       Operand<T> paddingValue) {
     return MatrixDiagPart.create(scope, input, k, paddingValue);
   }
@@ -1014,8 +1012,8 @@ public <T extends Tensor> MatrixDiagPart<T> matrixDiagPart(Operand<T> input, Ope
    * @param options carries optional attributes values
    * @return a new instance of MatrixDiagPartV3
    */
-  public <T extends Tensor> MatrixDiagPartV3<T> matrixDiagPartV3(Operand<T> input,
-      Operand<TInt32> k, Operand<T> paddingValue, MatrixDiagPartV3.Options... options) {
+  public <T extends TType> MatrixDiagPartV3<T> matrixDiagPartV3(Operand<T> input, Operand<TInt32> k,
+      Operand<T> paddingValue, MatrixDiagPartV3.Options... options) {
     return MatrixDiagPartV3.create(scope, input, k, paddingValue, options);
   }
 
@@ -1152,7 +1150,7 @@ public <T extends Tensor> MatrixDiagPartV3<T> matrixDiagPartV3(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of MatrixDiagV3
    */
-  public <T extends Tensor> MatrixDiagV3<T> matrixDiagV3(Operand<T> diagonal, Operand<TInt32> k,
+  public <T extends TType> MatrixDiagV3<T> matrixDiagV3(Operand<T> diagonal, Operand<TInt32> k,
       Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue,
       MatrixDiagV3.Options... options) {
     return MatrixDiagV3.create(scope, diagonal, k, numRows, numCols, paddingValue, options);
@@ -1273,7 +1271,7 @@ public <T extends Tensor> MatrixDiagV3<T> matrixDiagV3(Operand<T> diagonal, Oper
    * @param options carries optional attributes values
    * @return a new instance of MatrixSetDiag
    */
-  public <T extends Tensor> MatrixSetDiag<T> matrixSetDiag(Operand<T> input, Operand<T> diagonal,
+  public <T extends TType> MatrixSetDiag<T> matrixSetDiag(Operand<T> input, Operand<T> diagonal,
       Operand<TInt32> k, MatrixSetDiag.Options... options) {
     return MatrixSetDiag.create(scope, input, diagonal, k, options);
   }
@@ -1326,7 +1324,7 @@ public <T extends Tensor> MatrixSetDiag<T> matrixSetDiag(Operand<T> input, Opera
    * @param options carries optional attributes values
    * @return a new instance of MatrixSolveLs
    */
-  public <T extends Tensor> MatrixSolveLs<T> matrixSolveLs(Operand<T> matrix, Operand<T> rhs,
+  public <T extends TType> MatrixSolveLs<T> matrixSolveLs(Operand<T> matrix, Operand<T> rhs,
       Operand<TFloat64> l2Regularizer, MatrixSolveLs.Options... options) {
     return MatrixSolveLs.create(scope, matrix, rhs, l2Regularizer, options);
   }
@@ -1350,7 +1348,7 @@ public <T extends Tensor> MatrixSolveLs<T> matrixSolveLs(Operand<T> matrix, Oper
    * @param options carries optional attributes values
    * @return a new instance of Qr
    */
-  public <T extends Tensor> Qr<T> qr(Operand<T> input, Qr.Options... options) {
+  public <T extends TType> Qr<T> qr(Operand<T> input, Qr.Options... options) {
     return Qr.create(scope, input, options);
   }
 
@@ -1375,7 +1373,7 @@ public <T extends Tensor> Qr<T> qr(Operand<T> input, Qr.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of QuantizedMatMul
    */
-  public <V extends Tensor, T extends Tensor, U extends Tensor, W extends Tensor> QuantizedMatMul<V> quantizedMatMul(
+  public <V extends TType, T extends TType, U extends TType, W extends TType> QuantizedMatMul<V> quantizedMatMul(
       Operand<T> a, Operand<U> b, Operand<TFloat32> minA, Operand<TFloat32> maxA,
       Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, DataType<W> Tactivation,
       QuantizedMatMul.Options... options) {
@@ -1401,7 +1399,7 @@ public <V extends Tensor, T extends Tensor, U extends Tensor, W extends Tensor>
    * @param options carries optional attributes values
    * @return a new instance of SelfAdjointEig
    */
-  public <T extends Tensor> SelfAdjointEig<T> selfAdjointEig(Operand<T> input,
+  public <T extends TType> SelfAdjointEig<T> selfAdjointEig(Operand<T> input,
       SelfAdjointEig.Options... options) {
     return SelfAdjointEig.create(scope, input, options);
   }
@@ -1422,7 +1420,7 @@ public <T extends Tensor> SelfAdjointEig<T> selfAdjointEig(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of Solve
    */
-  public <T extends Tensor> Solve<T> solve(Operand<T> matrix, Operand<T> rhs,
+  public <T extends TType> Solve<T> solve(Operand<T> matrix, Operand<T> rhs,
       Solve.Options... options) {
     return Solve.create(scope, matrix, rhs, options);
   }
@@ -1450,7 +1448,7 @@ public <T extends Tensor> Solve<T> solve(Operand<T> matrix, Operand<T> rhs,
    * @param input Shape is `[..., M, M]`.
    * @return a new instance of Sqrtm
    */
-  public <T extends Tensor> Sqrtm<T> sqrtm(Operand<T> input) {
+  public <T extends TType> Sqrtm<T> sqrtm(Operand<T> input) {
     return Sqrtm.create(scope, input);
   }
 
@@ -1474,7 +1472,7 @@ public <T extends Tensor> Sqrtm<T> sqrtm(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of Svd
    */
-  public <T extends Tensor> Svd<T> svd(Operand<T> input, Svd.Options... options) {
+  public <T extends TType> Svd<T> svd(Operand<T> input, Svd.Options... options) {
     return Svd.create(scope, input, options);
   }
 
@@ -1502,7 +1500,7 @@ public <T extends Tensor> Svd<T> svd(Operand<T> input, Svd.Options... options) {
    * @param diagonal Rank k tensor where k is at most 1.
    * @return a new instance of TensorDiag
    */
-  public <T extends Tensor> TensorDiag<T> tensorDiag(Operand<T> diagonal) {
+  public <T extends TType> TensorDiag<T> tensorDiag(Operand<T> diagonal) {
     return TensorDiag.create(scope, diagonal);
   }
 
@@ -1531,7 +1529,7 @@ public <T extends Tensor> TensorDiag<T> tensorDiag(Operand<T> diagonal) {
    * @param input Rank k tensor where k is even and not zero.
    * @return a new instance of TensorDiagPart
    */
-  public <T extends Tensor> TensorDiagPart<T> tensorDiagPart(Operand<T> input) {
+  public <T extends TType> TensorDiagPart<T> tensorDiagPart(Operand<T> input) {
     return TensorDiagPart.create(scope, input);
   }
 
@@ -1546,7 +1544,7 @@ public <T extends Tensor> TensorDiagPart<T> tensorDiagPart(Operand<T> input) {
    * @param perm
    * @return a new instance of Transpose
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Transpose<T> transpose(Operand<T> x,
+  public <T extends TType, U extends TNumber> Transpose<T> transpose(Operand<T> x,
       Operand<U> perm) {
     return Transpose.create(scope, x, perm);
   }
@@ -1606,7 +1604,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Transpose<T> transpose(Ope
    * @param options carries optional attributes values
    * @return a new instance of TriangularSolve
    */
-  public <T extends Tensor> TriangularSolve<T> triangularSolve(Operand<T> matrix, Operand<T> rhs,
+  public <T extends TType> TriangularSolve<T> triangularSolve(Operand<T> matrix, Operand<T> rhs,
       TriangularSolve.Options... options) {
     return TriangularSolve.create(scope, matrix, rhs, options);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java
index 3c983272e6d..8da2c9ee3cd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/MathOps.java
@@ -19,7 +19,6 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.math.Abs;
 import org.tensorflow.op.math.AccumulateN;
@@ -130,6 +129,7 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code math} operations as {@link Op Op}s
@@ -154,7 +154,7 @@ public final class MathOps {
    * @param x
    * @return a new instance of Abs
    */
-  public <T extends Tensor & TNumber> Abs<T> abs(Operand<T> x) {
+  public <T extends TNumber> Abs<T> abs(Operand<T> x) {
     return Abs.create(scope, x);
   }
 
@@ -175,7 +175,7 @@ public <T extends Tensor & TNumber> Abs<T> abs(Operand<T> x) {
    * @param shape Shape of elements of `inputs`.
    * @return a new instance of AccumulateN
    */
-  public <T extends Tensor> AccumulateN<T> accumulateN(Iterable<Operand<T>> inputs, Shape shape) {
+  public <T extends TType> AccumulateN<T> accumulateN(Iterable<Operand<T>> inputs, Shape shape) {
     return AccumulateN.create(scope, inputs, shape);
   }
 
@@ -186,7 +186,7 @@ public <T extends Tensor> AccumulateN<T> accumulateN(Iterable<Operand<T>> inputs
    * @param x
    * @return a new instance of Acos
    */
-  public <T extends Tensor> Acos<T> acos(Operand<T> x) {
+  public <T extends TType> Acos<T> acos(Operand<T> x) {
     return Acos.create(scope, x);
   }
 
@@ -204,7 +204,7 @@ public <T extends Tensor> Acos<T> acos(Operand<T> x) {
    * @param x
    * @return a new instance of Acosh
    */
-  public <T extends Tensor> Acosh<T> acosh(Operand<T> x) {
+  public <T extends TType> Acosh<T> acosh(Operand<T> x) {
     return Acosh.create(scope, x);
   }
 
@@ -219,7 +219,7 @@ public <T extends Tensor> Acosh<T> acosh(Operand<T> x) {
    * @param y
    * @return a new instance of Add
    */
-  public <T extends Tensor> Add<T> add(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Add<T> add(Operand<T> x, Operand<T> y) {
     return Add.create(scope, x, y);
   }
 
@@ -237,7 +237,7 @@ public <T extends Tensor> Add<T> add(Operand<T> x, Operand<T> y) {
    * @param inputs
    * @return a new instance of AddN
    */
-  public <T extends Tensor> AddN<T> addN(Iterable<Operand<T>> inputs) {
+  public <T extends TType> AddN<T> addN(Iterable<Operand<T>> inputs) {
     return AddN.create(scope, inputs);
   }
 
@@ -263,7 +263,7 @@ public <T extends Tensor> AddN<T> addN(Iterable<Operand<T>> inputs) {
    * @param input
    * @return a new instance of Angle
    */
-  public <T extends Tensor> Angle<TFloat32> angle(Operand<T> input) {
+  public <T extends TType> Angle<TFloat32> angle(Operand<T> input) {
     return Angle.create(scope, input);
   }
 
@@ -290,8 +290,7 @@ public <T extends Tensor> Angle<TFloat32> angle(Operand<T> input) {
    * @param Tout
    * @return a new instance of Angle
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Angle<U> angle(Operand<T> input,
-      DataType<U> Tout) {
+  public <U extends TNumber, T extends TType> Angle<U> angle(Operand<T> input, DataType<U> Tout) {
     return Angle.create(scope, input, Tout);
   }
 
@@ -303,7 +302,7 @@ public <U extends Tensor & TNumber, T extends Tensor> Angle<U> angle(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of ApproximateEqual
    */
-  public <T extends Tensor> ApproximateEqual approximateEqual(Operand<T> x, Operand<T> y,
+  public <T extends TType> ApproximateEqual approximateEqual(Operand<T> x, Operand<T> y,
       ApproximateEqual.Options... options) {
     return ApproximateEqual.create(scope, x, y, options);
   }
@@ -330,7 +329,7 @@ public <T extends Tensor> ApproximateEqual approximateEqual(Operand<T> x, Operan
    *  use dimension = 0.
    * @return a new instance of ArgMax
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ArgMax<TInt64> argMax(Operand<T> input,
+  public <T extends TType, U extends TNumber> ArgMax<TInt64> argMax(Operand<T> input,
       Operand<U> dimension) {
     return ArgMax.create(scope, input, dimension);
   }
@@ -358,8 +357,8 @@ public <T extends Tensor, U extends Tensor & TNumber> ArgMax<TInt64> argMax(Oper
    * @param outputType
    * @return a new instance of ArgMax
    */
-  public <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMax<V> argMax(
-      Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
+  public <V extends TNumber, T extends TType, U extends TNumber> ArgMax<V> argMax(Operand<T> input,
+      Operand<U> dimension, DataType<V> outputType) {
     return ArgMax.create(scope, input, dimension, outputType);
   }
 
@@ -385,7 +384,7 @@ public <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber
    *  use dimension = 0.
    * @return a new instance of ArgMin
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ArgMin<TInt64> argMin(Operand<T> input,
+  public <T extends TType, U extends TNumber> ArgMin<TInt64> argMin(Operand<T> input,
       Operand<U> dimension) {
     return ArgMin.create(scope, input, dimension);
   }
@@ -413,8 +412,8 @@ public <T extends Tensor, U extends Tensor & TNumber> ArgMin<TInt64> argMin(Oper
    * @param outputType
    * @return a new instance of ArgMin
    */
-  public <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMin<V> argMin(
-      Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
+  public <V extends TNumber, T extends TType, U extends TNumber> ArgMin<V> argMin(Operand<T> input,
+      Operand<U> dimension, DataType<V> outputType) {
     return ArgMin.create(scope, input, dimension, outputType);
   }
 
@@ -440,7 +439,7 @@ public <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber
    * @param x
    * @return a new instance of Asin
    */
-  public <T extends Tensor> Asin<T> asin(Operand<T> x) {
+  public <T extends TType> Asin<T> asin(Operand<T> x) {
     return Asin.create(scope, x);
   }
 
@@ -460,7 +459,7 @@ public <T extends Tensor> Asin<T> asin(Operand<T> x) {
    * @param x
    * @return a new instance of Asinh
    */
-  public <T extends Tensor> Asinh<T> asinh(Operand<T> x) {
+  public <T extends TType> Asinh<T> asinh(Operand<T> x) {
     return Asinh.create(scope, x);
   }
 
@@ -486,7 +485,7 @@ public <T extends Tensor> Asinh<T> asinh(Operand<T> x) {
    * @param x
    * @return a new instance of Atan
    */
-  public <T extends Tensor> Atan<T> atan(Operand<T> x) {
+  public <T extends TType> Atan<T> atan(Operand<T> x) {
     return Atan.create(scope, x);
   }
 
@@ -504,7 +503,7 @@ public <T extends Tensor> Atan<T> atan(Operand<T> x) {
    * @param x
    * @return a new instance of Atan2
    */
-  public <T extends Tensor & TNumber> Atan2<T> atan2(Operand<T> y, Operand<T> x) {
+  public <T extends TNumber> Atan2<T> atan2(Operand<T> y, Operand<T> x) {
     return Atan2.create(scope, y, x);
   }
 
@@ -526,7 +525,7 @@ public <T extends Tensor & TNumber> Atan2<T> atan2(Operand<T> y, Operand<T> x) {
    * @param x
    * @return a new instance of Atanh
    */
-  public <T extends Tensor> Atanh<T> atanh(Operand<T> x) {
+  public <T extends TType> Atanh<T> atanh(Operand<T> x) {
     return Atanh.create(scope, x);
   }
 
@@ -542,7 +541,7 @@ public <T extends Tensor> Atanh<T> atanh(Operand<T> x) {
    * @param x
    * @return a new instance of BesselI0e
    */
-  public <T extends Tensor & TNumber> BesselI0e<T> besselI0e(Operand<T> x) {
+  public <T extends TNumber> BesselI0e<T> besselI0e(Operand<T> x) {
     return BesselI0e.create(scope, x);
   }
 
@@ -558,7 +557,7 @@ public <T extends Tensor & TNumber> BesselI0e<T> besselI0e(Operand<T> x) {
    * @param x
    * @return a new instance of BesselI1e
    */
-  public <T extends Tensor & TNumber> BesselI1e<T> besselI1e(Operand<T> x) {
+  public <T extends TNumber> BesselI1e<T> besselI1e(Operand<T> x) {
     return BesselI1e.create(scope, x);
   }
 
@@ -582,7 +581,7 @@ public <T extends Tensor & TNumber> BesselI1e<T> besselI1e(Operand<T> x) {
    * @param x
    * @return a new instance of Betainc
    */
-  public <T extends Tensor & TNumber> Betainc<T> betainc(Operand<T> a, Operand<T> b, Operand<T> x) {
+  public <T extends TNumber> Betainc<T> betainc(Operand<T> a, Operand<T> b, Operand<T> x) {
     return Betainc.create(scope, a, b, x);
   }
 
@@ -605,8 +604,8 @@ public <T extends Tensor & TNumber> Betainc<T> betainc(Operand<T> a, Operand<T>
    *  equal to 1.
    * @return a new instance of Bincount
    */
-  public <T extends Tensor & TNumber> Bincount<T> bincount(Operand<TInt32> arr,
-      Operand<TInt32> size, Operand<T> weights) {
+  public <T extends TNumber> Bincount<T> bincount(Operand<TInt32> arr, Operand<TInt32> size,
+      Operand<T> weights) {
     return Bincount.create(scope, arr, size, weights);
   }
 
@@ -617,7 +616,7 @@ public <T extends Tensor & TNumber> Bincount<T> bincount(Operand<TInt32> arr,
    * @param x
    * @return a new instance of Ceil
    */
-  public <T extends Tensor & TNumber> Ceil<T> ceil(Operand<T> x) {
+  public <T extends TNumber> Ceil<T> ceil(Operand<T> x) {
     return Ceil.create(scope, x);
   }
 
@@ -650,7 +649,7 @@ public <T extends Tensor & TNumber> Ceil<T> ceil(Operand<T> x) {
    * @param threshold Threshold to compare against.
    * @return a new instance of CompareAndBitpack
    */
-  public <T extends Tensor> CompareAndBitpack compareAndBitpack(Operand<T> input,
+  public <T extends TType> CompareAndBitpack compareAndBitpack(Operand<T> input,
       Operand<T> threshold) {
     return CompareAndBitpack.create(scope, input, threshold);
   }
@@ -667,7 +666,7 @@ public <T extends Tensor> CompareAndBitpack compareAndBitpack(Operand<T> input,
    * @param x
    * @return a new instance of ComplexAbs
    */
-  public <T extends Tensor> ComplexAbs<TFloat32> complexAbs(Operand<T> x) {
+  public <T extends TType> ComplexAbs<TFloat32> complexAbs(Operand<T> x) {
     return ComplexAbs.create(scope, x);
   }
 
@@ -684,7 +683,7 @@ public <T extends Tensor> ComplexAbs<TFloat32> complexAbs(Operand<T> x) {
    * @param Tout
    * @return a new instance of ComplexAbs
    */
-  public <U extends Tensor & TNumber, T extends Tensor> ComplexAbs<U> complexAbs(Operand<T> x,
+  public <U extends TNumber, T extends TType> ComplexAbs<U> complexAbs(Operand<T> x,
       DataType<U> Tout) {
     return ComplexAbs.create(scope, x, Tout);
   }
@@ -709,7 +708,7 @@ public <U extends Tensor & TNumber, T extends Tensor> ComplexAbs<U> complexAbs(O
    * @param input
    * @return a new instance of Conj
    */
-  public <T extends Tensor> Conj<T> conj(Operand<T> input) {
+  public <T extends TType> Conj<T> conj(Operand<T> input) {
     return Conj.create(scope, input);
   }
 
@@ -730,7 +729,7 @@ public <T extends Tensor> Conj<T> conj(Operand<T> input) {
    * @param x
    * @return a new instance of Cos
    */
-  public <T extends Tensor> Cos<T> cos(Operand<T> x) {
+  public <T extends TType> Cos<T> cos(Operand<T> x) {
     return Cos.create(scope, x);
   }
 
@@ -750,7 +749,7 @@ public <T extends Tensor> Cos<T> cos(Operand<T> x) {
    * @param x
    * @return a new instance of Cosh
    */
-  public <T extends Tensor> Cosh<T> cosh(Operand<T> x) {
+  public <T extends TType> Cosh<T> cosh(Operand<T> x) {
     return Cosh.create(scope, x);
   }
 
@@ -788,8 +787,8 @@ public <T extends Tensor> Cosh<T> cosh(Operand<T> x) {
    * @param options carries optional attributes values
    * @return a new instance of Cumprod
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Cumprod<T> cumprod(Operand<T> x,
-      Operand<U> axis, Cumprod.Options... options) {
+  public <T extends TType, U extends TNumber> Cumprod<T> cumprod(Operand<T> x, Operand<U> axis,
+      Cumprod.Options... options) {
     return Cumprod.create(scope, x, axis, options);
   }
 
@@ -827,8 +826,8 @@ public <T extends Tensor, U extends Tensor & TNumber> Cumprod<T> cumprod(Operand
    * @param options carries optional attributes values
    * @return a new instance of Cumsum
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Cumsum<T> cumsum(Operand<T> x,
-      Operand<U> axis, Cumsum.Options... options) {
+  public <T extends TType, U extends TNumber> Cumsum<T> cumsum(Operand<T> x, Operand<U> axis,
+      Cumsum.Options... options) {
     return Cumsum.create(scope, x, axis, options);
   }
 
@@ -841,7 +840,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Cumsum<T> cumsum(Operand<T
    * @param x
    * @return a new instance of Digamma
    */
-  public <T extends Tensor & TNumber> Digamma<T> digamma(Operand<T> x) {
+  public <T extends TNumber> Digamma<T> digamma(Operand<T> x) {
     return Digamma.create(scope, x);
   }
 
@@ -856,7 +855,7 @@ public <T extends Tensor & TNumber> Digamma<T> digamma(Operand<T> x) {
    * @param y
    * @return a new instance of Div
    */
-  public <T extends Tensor> Div<T> div(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Div<T> div(Operand<T> x, Operand<T> y) {
     return Div.create(scope, x, y);
   }
 
@@ -872,7 +871,7 @@ public <T extends Tensor> Div<T> div(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of DivNoNan
    */
-  public <T extends Tensor> DivNoNan<T> divNoNan(Operand<T> x, Operand<T> y) {
+  public <T extends TType> DivNoNan<T> divNoNan(Operand<T> x, Operand<T> y) {
     return DivNoNan.create(scope, x, y);
   }
 
@@ -896,7 +895,7 @@ public <T extends Tensor> DivNoNan<T> divNoNan(Operand<T> x, Operand<T> y) {
    * @param options carries optional attributes values
    * @return a new instance of Equal
    */
-  public <T extends Tensor> Equal equal(Operand<T> x, Operand<T> y, Equal.Options... options) {
+  public <T extends TType> Equal equal(Operand<T> x, Operand<T> y, Equal.Options... options) {
     return Equal.create(scope, x, y, options);
   }
 
@@ -907,7 +906,7 @@ public <T extends Tensor> Equal equal(Operand<T> x, Operand<T> y, Equal.Options.
    * @param x
    * @return a new instance of Erf
    */
-  public <T extends Tensor & TNumber> Erf<T> erf(Operand<T> x) {
+  public <T extends TNumber> Erf<T> erf(Operand<T> x) {
     return Erf.create(scope, x);
   }
 
@@ -918,7 +917,7 @@ public <T extends Tensor & TNumber> Erf<T> erf(Operand<T> x) {
    * @param x
    * @return a new instance of Erfc
    */
-  public <T extends Tensor & TNumber> Erfc<T> erfc(Operand<T> x) {
+  public <T extends TNumber> Erfc<T> erfc(Operand<T> x) {
     return Erfc.create(scope, x);
   }
 
@@ -928,7 +927,7 @@ public <T extends Tensor & TNumber> Erfc<T> erfc(Operand<T> x) {
    * @param x
    * @return a new instance of erfinv
    */
-  public <T extends Tensor & TNumber> erfinv<T> erfinv(Operand<T> x) {
+  public <T extends TNumber> erfinv<T> erfinv(Operand<T> x) {
     return erfinv.create(scope, x);
   }
 
@@ -964,7 +963,7 @@ public <T extends Tensor & TNumber> erfinv<T> erfinv(Operand<T> x) {
    * @param x
    * @return a new instance of Exp
    */
-  public <T extends Tensor> Exp<T> exp(Operand<T> x) {
+  public <T extends TType> Exp<T> exp(Operand<T> x) {
     return Exp.create(scope, x);
   }
 
@@ -989,7 +988,7 @@ public <T extends Tensor> Exp<T> exp(Operand<T> x) {
    * @param x
    * @return a new instance of Expm1
    */
-  public <T extends Tensor> Expm1<T> expm1(Operand<T> x) {
+  public <T extends TType> Expm1<T> expm1(Operand<T> x) {
     return Expm1.create(scope, x);
   }
 
@@ -1009,7 +1008,7 @@ public Fact fact() {
    * @param x
    * @return a new instance of Floor
    */
-  public <T extends Tensor & TNumber> Floor<T> floor(Operand<T> x) {
+  public <T extends TNumber> Floor<T> floor(Operand<T> x) {
     return Floor.create(scope, x);
   }
 
@@ -1024,7 +1023,7 @@ public <T extends Tensor & TNumber> Floor<T> floor(Operand<T> x) {
    * @param y
    * @return a new instance of FloorDiv
    */
-  public <T extends Tensor> FloorDiv<T> floorDiv(Operand<T> x, Operand<T> y) {
+  public <T extends TType> FloorDiv<T> floorDiv(Operand<T> x, Operand<T> y) {
     return FloorDiv.create(scope, x, y);
   }
 
@@ -1042,7 +1041,7 @@ public <T extends Tensor> FloorDiv<T> floorDiv(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of FloorMod
    */
-  public <T extends Tensor & TNumber> FloorMod<T> floorMod(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> FloorMod<T> floorMod(Operand<T> x, Operand<T> y) {
     return FloorMod.create(scope, x, y);
   }
 
@@ -1067,7 +1066,7 @@ public <T extends Tensor & TNumber> FloorMod<T> floorMod(Operand<T> x, Operand<T
    * @param y
    * @return a new instance of Greater
    */
-  public <T extends Tensor & TNumber> Greater greater(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> Greater greater(Operand<T> x, Operand<T> y) {
     return Greater.create(scope, x, y);
   }
 
@@ -1092,7 +1091,7 @@ public <T extends Tensor & TNumber> Greater greater(Operand<T> x, Operand<T> y)
    * @param y
    * @return a new instance of GreaterEqual
    */
-  public <T extends Tensor & TNumber> GreaterEqual greaterEqual(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> GreaterEqual greaterEqual(Operand<T> x, Operand<T> y) {
     return GreaterEqual.create(scope, x, y);
   }
 
@@ -1117,7 +1116,7 @@ public <T extends Tensor & TNumber> GreaterEqual greaterEqual(Operand<T> x, Oper
    * @param x
    * @return a new instance of Igamma
    */
-  public <T extends Tensor & TNumber> Igamma<T> igamma(Operand<T> a, Operand<T> x) {
+  public <T extends TNumber> Igamma<T> igamma(Operand<T> a, Operand<T> x) {
     return Igamma.create(scope, a, x);
   }
 
@@ -1142,7 +1141,7 @@ public <T extends Tensor & TNumber> Igamma<T> igamma(Operand<T> a, Operand<T> x)
    * @param x
    * @return a new instance of Igammac
    */
-  public <T extends Tensor & TNumber> Igammac<T> igammac(Operand<T> a, Operand<T> x) {
+  public <T extends TNumber> Igammac<T> igammac(Operand<T> a, Operand<T> x) {
     return Igammac.create(scope, a, x);
   }
 
@@ -1164,7 +1163,7 @@ public <T extends Tensor & TNumber> Igammac<T> igammac(Operand<T> a, Operand<T>
    * @param input
    * @return a new instance of Imag
    */
-  public <T extends Tensor> Imag<TFloat32> imag(Operand<T> input) {
+  public <T extends TType> Imag<TFloat32> imag(Operand<T> input) {
     return Imag.create(scope, input);
   }
 
@@ -1187,8 +1186,7 @@ public <T extends Tensor> Imag<TFloat32> imag(Operand<T> input) {
    * @param Tout
    * @return a new instance of Imag
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Imag<U> imag(Operand<T> input,
-      DataType<U> Tout) {
+  public <U extends TNumber, T extends TType> Imag<U> imag(Operand<T> input, DataType<U> Tout) {
     return Imag.create(scope, input, Tout);
   }
 
@@ -1214,7 +1212,7 @@ public <U extends Tensor & TNumber, T extends Tensor> Imag<U> imag(Operand<T> in
    * @param x 1-D.
    * @return a new instance of InvertPermutation
    */
-  public <T extends Tensor & TNumber> InvertPermutation<T> invertPermutation(Operand<T> x) {
+  public <T extends TNumber> InvertPermutation<T> invertPermutation(Operand<T> x) {
     return InvertPermutation.create(scope, x);
   }
 
@@ -1232,7 +1230,7 @@ public <T extends Tensor & TNumber> InvertPermutation<T> invertPermutation(Opera
    * @param x
    * @return a new instance of IsFinite
    */
-  public <T extends Tensor & TNumber> IsFinite isFinite(Operand<T> x) {
+  public <T extends TNumber> IsFinite isFinite(Operand<T> x) {
     return IsFinite.create(scope, x);
   }
 
@@ -1250,7 +1248,7 @@ public <T extends Tensor & TNumber> IsFinite isFinite(Operand<T> x) {
    * @param x
    * @return a new instance of IsInf
    */
-  public <T extends Tensor & TNumber> IsInf isInf(Operand<T> x) {
+  public <T extends TNumber> IsInf isInf(Operand<T> x) {
     return IsInf.create(scope, x);
   }
 
@@ -1268,7 +1266,7 @@ public <T extends Tensor & TNumber> IsInf isInf(Operand<T> x) {
    * @param x
    * @return a new instance of IsNan
    */
-  public <T extends Tensor & TNumber> IsNan isNan(Operand<T> x) {
+  public <T extends TNumber> IsNan isNan(Operand<T> x) {
     return IsNan.create(scope, x);
   }
 
@@ -1293,7 +1291,7 @@ public <T extends Tensor & TNumber> IsNan isNan(Operand<T> x) {
    * @param y
    * @return a new instance of Less
    */
-  public <T extends Tensor & TNumber> Less less(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> Less less(Operand<T> x, Operand<T> y) {
     return Less.create(scope, x, y);
   }
 
@@ -1318,7 +1316,7 @@ public <T extends Tensor & TNumber> Less less(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of LessEqual
    */
-  public <T extends Tensor & TNumber> LessEqual lessEqual(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> LessEqual lessEqual(Operand<T> x, Operand<T> y) {
     return LessEqual.create(scope, x, y);
   }
 
@@ -1338,7 +1336,7 @@ public <T extends Tensor & TNumber> LessEqual lessEqual(Operand<T> x, Operand<T>
    * @param x
    * @return a new instance of Lgamma
    */
-  public <T extends Tensor & TNumber> Lgamma<T> lgamma(Operand<T> x) {
+  public <T extends TNumber> Lgamma<T> lgamma(Operand<T> x) {
     return Lgamma.create(scope, x);
   }
 
@@ -1357,7 +1355,7 @@ public <T extends Tensor & TNumber> Lgamma<T> lgamma(Operand<T> x) {
    * @param x
    * @return a new instance of Log
    */
-  public <T extends Tensor> Log<T> log(Operand<T> x) {
+  public <T extends TType> Log<T> log(Operand<T> x) {
     return Log.create(scope, x);
   }
 
@@ -1376,7 +1374,7 @@ public <T extends Tensor> Log<T> log(Operand<T> x) {
    * @param x
    * @return a new instance of Log1p
    */
-  public <T extends Tensor> Log1p<T> log1p(Operand<T> x) {
+  public <T extends TType> Log1p<T> log1p(Operand<T> x) {
     return Log1p.create(scope, x);
   }
 
@@ -1429,7 +1427,7 @@ public LogicalOr logicalOr(Operand<TBool> x, Operand<TBool> y) {
    * @param y
    * @return a new instance of Maximum
    */
-  public <T extends Tensor & TNumber> Maximum<T> maximum(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> Maximum<T> maximum(Operand<T> x, Operand<T> y) {
     return Maximum.create(scope, x, y);
   }
 
@@ -1448,8 +1446,8 @@ public <T extends Tensor & TNumber> Maximum<T> maximum(Operand<T> x, Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of Mean
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Mean<T> mean(Operand<T> input,
-      Operand<U> axis, Mean.Options... options) {
+  public <T extends TType, U extends TNumber> Mean<T> mean(Operand<T> input, Operand<U> axis,
+      Mean.Options... options) {
     return Mean.create(scope, input, axis, options);
   }
 
@@ -1464,7 +1462,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Mean<T> mean(Operand<T> in
    * @param y
    * @return a new instance of Minimum
    */
-  public <T extends Tensor & TNumber> Minimum<T> minimum(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> Minimum<T> minimum(Operand<T> x, Operand<T> y) {
     return Minimum.create(scope, x, y);
   }
 
@@ -1482,7 +1480,7 @@ public <T extends Tensor & TNumber> Minimum<T> minimum(Operand<T> x, Operand<T>
    * @param y
    * @return a new instance of Mod
    */
-  public <T extends Tensor & TNumber> Mod<T> mod(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> Mod<T> mod(Operand<T> x, Operand<T> y) {
     return Mod.create(scope, x, y);
   }
 
@@ -1497,7 +1495,7 @@ public <T extends Tensor & TNumber> Mod<T> mod(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Mul
    */
-  public <T extends Tensor> Mul<T> mul(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Mul<T> mul(Operand<T> x, Operand<T> y) {
     return Mul.create(scope, x, y);
   }
 
@@ -1512,7 +1510,7 @@ public <T extends Tensor> Mul<T> mul(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of MulNoNan
    */
-  public <T extends Tensor> MulNoNan<T> mulNoNan(Operand<T> x, Operand<T> y) {
+  public <T extends TType> MulNoNan<T> mulNoNan(Operand<T> x, Operand<T> y) {
     return MulNoNan.create(scope, x, y);
   }
 
@@ -1522,7 +1520,7 @@ public <T extends Tensor> MulNoNan<T> mulNoNan(Operand<T> x, Operand<T> y) {
    * @param x
    * @return a new instance of Ndtri
    */
-  public <T extends Tensor & TNumber> Ndtri<T> ndtri(Operand<T> x) {
+  public <T extends TNumber> Ndtri<T> ndtri(Operand<T> x) {
     return Ndtri.create(scope, x);
   }
 
@@ -1535,7 +1533,7 @@ public <T extends Tensor & TNumber> Ndtri<T> ndtri(Operand<T> x) {
    * @param x
    * @return a new instance of Neg
    */
-  public <T extends Tensor> Neg<T> neg(Operand<T> x) {
+  public <T extends TType> Neg<T> neg(Operand<T> x) {
     return Neg.create(scope, x);
   }
 
@@ -1554,7 +1552,7 @@ public <T extends Tensor> Neg<T> neg(Operand<T> x) {
    * @param x2
    * @return a new instance of NextAfter
    */
-  public <T extends Tensor & TNumber> NextAfter<T> nextAfter(Operand<T> x1, Operand<T> x2) {
+  public <T extends TNumber> NextAfter<T> nextAfter(Operand<T> x1, Operand<T> x2) {
     return NextAfter.create(scope, x1, x2);
   }
 
@@ -1569,7 +1567,7 @@ public <T extends Tensor & TNumber> NextAfter<T> nextAfter(Operand<T> x1, Operan
    * @param options carries optional attributes values
    * @return a new instance of NotEqual
    */
-  public <T extends Tensor> NotEqual notEqual(Operand<T> x, Operand<T> y,
+  public <T extends TType> NotEqual notEqual(Operand<T> x, Operand<T> y,
       NotEqual.Options... options) {
     return NotEqual.create(scope, x, y, options);
   }
@@ -1589,7 +1587,7 @@ public <T extends Tensor> NotEqual notEqual(Operand<T> x, Operand<T> y,
    * @param x
    * @return a new instance of Polygamma
    */
-  public <T extends Tensor & TNumber> Polygamma<T> polygamma(Operand<T> a, Operand<T> x) {
+  public <T extends TNumber> Polygamma<T> polygamma(Operand<T> a, Operand<T> x) {
     return Polygamma.create(scope, a, x);
   }
 
@@ -1606,7 +1604,7 @@ public <T extends Tensor & TNumber> Polygamma<T> polygamma(Operand<T> a, Operand
    * @param x
    * @return a new instance of PopulationCount
    */
-  public <T extends Tensor & TNumber> PopulationCount populationCount(Operand<T> x) {
+  public <T extends TNumber> PopulationCount populationCount(Operand<T> x) {
     return PopulationCount.create(scope, x);
   }
 
@@ -1626,7 +1624,7 @@ public <T extends Tensor & TNumber> PopulationCount populationCount(Operand<T> x
    * @param y
    * @return a new instance of Pow
    */
-  public <T extends Tensor> Pow<T> pow(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Pow<T> pow(Operand<T> x, Operand<T> y) {
     return Pow.create(scope, x, y);
   }
 
@@ -1643,7 +1641,7 @@ public <T extends Tensor> Pow<T> pow(Operand<T> x, Operand<T> y) {
    * @param Toutput
    * @return a new instance of QuantizedAdd
    */
-  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedAdd<V> quantizedAdd(
+  public <V extends TType, T extends TType, U extends TType> QuantizedAdd<V> quantizedAdd(
       Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX,
       Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     return QuantizedAdd.create(scope, x, y, minX, maxX, minY, maxY, Toutput);
@@ -1662,7 +1660,7 @@ public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedAdd<V> qu
    * @param Toutput
    * @return a new instance of QuantizedMul
    */
-  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedMul<V> quantizedMul(
+  public <V extends TType, T extends TType, U extends TType> QuantizedMul<V> quantizedMul(
       Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX,
       Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     return QuantizedMul.create(scope, x, y, minX, maxX, minY, maxY, Toutput);
@@ -1686,7 +1684,7 @@ public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedMul<V> qu
    * @param input
    * @return a new instance of Real
    */
-  public <T extends Tensor> Real<TFloat32> real(Operand<T> input) {
+  public <T extends TType> Real<TFloat32> real(Operand<T> input) {
     return Real.create(scope, input);
   }
 
@@ -1709,8 +1707,7 @@ public <T extends Tensor> Real<TFloat32> real(Operand<T> input) {
    * @param Tout
    * @return a new instance of Real
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Real<U> real(Operand<T> input,
-      DataType<U> Tout) {
+  public <U extends TNumber, T extends TType> Real<U> real(Operand<T> input, DataType<U> Tout) {
     return Real.create(scope, input, Tout);
   }
 
@@ -1727,7 +1724,7 @@ public <U extends Tensor & TNumber, T extends Tensor> Real<U> real(Operand<T> in
    * @param y
    * @return a new instance of RealDiv
    */
-  public <T extends Tensor> RealDiv<T> realDiv(Operand<T> x, Operand<T> y) {
+  public <T extends TType> RealDiv<T> realDiv(Operand<T> x, Operand<T> y) {
     return RealDiv.create(scope, x, y);
   }
 
@@ -1740,7 +1737,7 @@ public <T extends Tensor> RealDiv<T> realDiv(Operand<T> x, Operand<T> y) {
    * @param x
    * @return a new instance of Reciprocal
    */
-  public <T extends Tensor> Reciprocal<T> reciprocal(Operand<T> x) {
+  public <T extends TType> Reciprocal<T> reciprocal(Operand<T> x) {
     return Reciprocal.create(scope, x);
   }
 
@@ -1760,7 +1757,7 @@ public <T extends Tensor> Reciprocal<T> reciprocal(Operand<T> x) {
    * @param x
    * @return a new instance of Rint
    */
-  public <T extends Tensor & TNumber> Rint<T> rint(Operand<T> x) {
+  public <T extends TNumber> Rint<T> rint(Operand<T> x) {
     return Rint.create(scope, x);
   }
 
@@ -1774,7 +1771,7 @@ public <T extends Tensor & TNumber> Rint<T> rint(Operand<T> x) {
    * @param x
    * @return a new instance of Round
    */
-  public <T extends Tensor> Round<T> round(Operand<T> x) {
+  public <T extends TType> Round<T> round(Operand<T> x) {
     return Round.create(scope, x);
   }
 
@@ -1787,7 +1784,7 @@ public <T extends Tensor> Round<T> round(Operand<T> x) {
    * @param x
    * @return a new instance of Rsqrt
    */
-  public <T extends Tensor> Rsqrt<T> rsqrt(Operand<T> x) {
+  public <T extends TType> Rsqrt<T> rsqrt(Operand<T> x) {
     return Rsqrt.create(scope, x);
   }
 
@@ -1822,8 +1819,8 @@ public <T extends Tensor> Rsqrt<T> rsqrt(Operand<T> x) {
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentMax
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMax<T> segmentMax(
-      Operand<T> data, Operand<U> segmentIds) {
+  public <T extends TNumber, U extends TNumber> SegmentMax<T> segmentMax(Operand<T> data,
+      Operand<U> segmentIds) {
     return SegmentMax.create(scope, data, segmentIds);
   }
 
@@ -1859,7 +1856,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMax<T> se
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentMean
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SegmentMean<T> segmentMean(Operand<T> data,
+  public <T extends TType, U extends TNumber> SegmentMean<T> segmentMean(Operand<T> data,
       Operand<U> segmentIds) {
     return SegmentMean.create(scope, data, segmentIds);
   }
@@ -1895,8 +1892,8 @@ public <T extends Tensor, U extends Tensor & TNumber> SegmentMean<T> segmentMean
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentMin
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMin<T> segmentMin(
-      Operand<T> data, Operand<U> segmentIds) {
+  public <T extends TNumber, U extends TNumber> SegmentMin<T> segmentMin(Operand<T> data,
+      Operand<U> segmentIds) {
     return SegmentMin.create(scope, data, segmentIds);
   }
 
@@ -1931,7 +1928,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMin<T> se
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentProd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SegmentProd<T> segmentProd(Operand<T> data,
+  public <T extends TType, U extends TNumber> SegmentProd<T> segmentProd(Operand<T> data,
       Operand<U> segmentIds) {
     return SegmentProd.create(scope, data, segmentIds);
   }
@@ -1967,7 +1964,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SegmentProd<T> segmentProd
    *  first dimension.  Values should be sorted and can be repeated.
    * @return a new instance of SegmentSum
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SegmentSum<T> segmentSum(Operand<T> data,
+  public <T extends TType, U extends TNumber> SegmentSum<T> segmentSum(Operand<T> data,
       Operand<U> segmentIds) {
     return SegmentSum.create(scope, data, segmentIds);
   }
@@ -1981,7 +1978,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SegmentSum<T> segmentSum(O
    * @param x
    * @return a new instance of Sigmoid
    */
-  public <T extends Tensor> Sigmoid<T> sigmoid(Operand<T> x) {
+  public <T extends TType> Sigmoid<T> sigmoid(Operand<T> x) {
     return Sigmoid.create(scope, x);
   }
 
@@ -2000,7 +1997,7 @@ public <T extends Tensor> Sigmoid<T> sigmoid(Operand<T> x) {
    * @param x
    * @return a new instance of Sign
    */
-  public <T extends Tensor> Sign<T> sign(Operand<T> x) {
+  public <T extends TType> Sign<T> sign(Operand<T> x) {
     return Sign.create(scope, x);
   }
 
@@ -2020,7 +2017,7 @@ public <T extends Tensor> Sign<T> sign(Operand<T> x) {
    * @param x
    * @return a new instance of Sin
    */
-  public <T extends Tensor> Sin<T> sin(Operand<T> x) {
+  public <T extends TType> Sin<T> sin(Operand<T> x) {
     return Sin.create(scope, x);
   }
 
@@ -2040,7 +2037,7 @@ public <T extends Tensor> Sin<T> sin(Operand<T> x) {
    * @param x
    * @return a new instance of Sinh
    */
-  public <T extends Tensor> Sinh<T> sinh(Operand<T> x) {
+  public <T extends TType> Sinh<T> sinh(Operand<T> x) {
     return Sinh.create(scope, x);
   }
 
@@ -2051,7 +2048,7 @@ public <T extends Tensor> Sinh<T> sinh(Operand<T> x) {
    * @param features
    * @return a new instance of Softplus
    */
-  public <T extends Tensor & TNumber> Softplus<T> softplus(Operand<T> features) {
+  public <T extends TNumber> Softplus<T> softplus(Operand<T> features) {
     return Softplus.create(scope, features);
   }
 
@@ -2064,7 +2061,7 @@ public <T extends Tensor & TNumber> Softplus<T> softplus(Operand<T> features) {
    * @param x
    * @return a new instance of Sqrt
    */
-  public <T extends Tensor> Sqrt<T> sqrt(Operand<T> x) {
+  public <T extends TType> Sqrt<T> sqrt(Operand<T> x) {
     return Sqrt.create(scope, x);
   }
 
@@ -2077,7 +2074,7 @@ public <T extends Tensor> Sqrt<T> sqrt(Operand<T> x) {
    * @param x
    * @return a new instance of Square
    */
-  public <T extends Tensor> Square<T> square(Operand<T> x) {
+  public <T extends TType> Square<T> square(Operand<T> x) {
     return Square.create(scope, x);
   }
 
@@ -2092,7 +2089,7 @@ public <T extends Tensor> Square<T> square(Operand<T> x) {
    * @param y
    * @return a new instance of SquaredDifference
    */
-  public <T extends Tensor> SquaredDifference<T> squaredDifference(Operand<T> x, Operand<T> y) {
+  public <T extends TType> SquaredDifference<T> squaredDifference(Operand<T> x, Operand<T> y) {
     return SquaredDifference.create(scope, x, y);
   }
 
@@ -2107,7 +2104,7 @@ public <T extends Tensor> SquaredDifference<T> squaredDifference(Operand<T> x, O
    * @param y
    * @return a new instance of Sub
    */
-  public <T extends Tensor> Sub<T> sub(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Sub<T> sub(Operand<T> x, Operand<T> y) {
     return Sub.create(scope, x, y);
   }
 
@@ -2128,7 +2125,7 @@ public <T extends Tensor> Sub<T> sub(Operand<T> x, Operand<T> y) {
    * @param x
    * @return a new instance of Tan
    */
-  public <T extends Tensor> Tan<T> tan(Operand<T> x) {
+  public <T extends TType> Tan<T> tan(Operand<T> x) {
     return Tan.create(scope, x);
   }
 
@@ -2148,7 +2145,7 @@ public <T extends Tensor> Tan<T> tan(Operand<T> x) {
    * @param x
    * @return a new instance of Tanh
    */
-  public <T extends Tensor> Tanh<T> tanh(Operand<T> x) {
+  public <T extends TType> Tanh<T> tanh(Operand<T> x) {
     return Tanh.create(scope, x);
   }
 
@@ -2168,7 +2165,7 @@ public <T extends Tensor> Tanh<T> tanh(Operand<T> x) {
    * @param y
    * @return a new instance of TruncateDiv
    */
-  public <T extends Tensor> TruncateDiv<T> truncateDiv(Operand<T> x, Operand<T> y) {
+  public <T extends TType> TruncateDiv<T> truncateDiv(Operand<T> x, Operand<T> y) {
     return TruncateDiv.create(scope, x, y);
   }
 
@@ -2186,7 +2183,7 @@ public <T extends Tensor> TruncateDiv<T> truncateDiv(Operand<T> x, Operand<T> y)
    * @param y
    * @return a new instance of TruncateMod
    */
-  public <T extends Tensor & TNumber> TruncateMod<T> truncateMod(Operand<T> x, Operand<T> y) {
+  public <T extends TNumber> TruncateMod<T> truncateMod(Operand<T> x, Operand<T> y) {
     return TruncateMod.create(scope, x, y);
   }
 
@@ -2229,7 +2226,7 @@ public <T extends Tensor & TNumber> TruncateMod<T> truncateMod(Operand<T> x, Ope
    * @param numSegments
    * @return a new instance of UnsortedSegmentMax
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMax<T> unsortedSegmentMax(
+  public <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMax<T> unsortedSegmentMax(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentMax.create(scope, data, segmentIds, numSegments);
   }
@@ -2268,7 +2265,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor
    * @param numSegments
    * @return a new instance of UnsortedSegmentMin
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMin<T> unsortedSegmentMin(
+  public <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMin<T> unsortedSegmentMin(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentMin.create(scope, data, segmentIds, numSegments);
   }
@@ -2306,7 +2303,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor
    * @param numSegments
    * @return a new instance of UnsortedSegmentProd
    */
-  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentProd<T> unsortedSegmentProd(
+  public <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentProd<T> unsortedSegmentProd(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentProd.create(scope, data, segmentIds, numSegments);
   }
@@ -2346,7 +2343,7 @@ public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber
    * @param numSegments
    * @return a new instance of UnsortedSegmentSum
    */
-  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentSum<T> unsortedSegmentSum(
+  public <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentSum<T> unsortedSegmentSum(
       Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     return UnsortedSegmentSum.create(scope, data, segmentIds, numSegments);
   }
@@ -2359,7 +2356,7 @@ public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber
    * @param y
    * @return a new instance of Xdivy
    */
-  public <T extends Tensor> Xdivy<T> xdivy(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Xdivy<T> xdivy(Operand<T> x, Operand<T> y) {
     return Xdivy.create(scope, x, y);
   }
 
@@ -2371,7 +2368,7 @@ public <T extends Tensor> Xdivy<T> xdivy(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Xlog1py
    */
-  public <T extends Tensor> Xlog1py<T> xlog1py(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Xlog1py<T> xlog1py(Operand<T> x, Operand<T> y) {
     return Xlog1py.create(scope, x, y);
   }
 
@@ -2383,7 +2380,7 @@ public <T extends Tensor> Xlog1py<T> xlog1py(Operand<T> x, Operand<T> y) {
    * @param y
    * @return a new instance of Xlogy
    */
-  public <T extends Tensor> Xlogy<T> xlogy(Operand<T> x, Operand<T> y) {
+  public <T extends TType> Xlogy<T> xlogy(Operand<T> x, Operand<T> y) {
     return Xlogy.create(scope, x, y);
   }
 
@@ -2399,7 +2396,7 @@ public <T extends Tensor> Xlogy<T> xlogy(Operand<T> x, Operand<T> y) {
    * @param q
    * @return a new instance of Zeta
    */
-  public <T extends Tensor & TNumber> Zeta<T> zeta(Operand<T> x, Operand<T> q) {
+  public <T extends TNumber> Zeta<T> zeta(Operand<T> x, Operand<T> q) {
     return Zeta.create(scope, x, q);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java
index ebb56767bce..0c76b961cf4 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/NnOps.java
@@ -20,7 +20,6 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.nn.AvgPool;
 import org.tensorflow.op.nn.AvgPool3d;
 import org.tensorflow.op.nn.AvgPool3dGrad;
@@ -95,6 +94,7 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code nn} operations as {@link Op Op}s
@@ -122,7 +122,7 @@ public final class NnOps {
    * @param options carries optional attributes values
    * @return a new instance of AvgPool
    */
-  public <T extends Tensor & TNumber> AvgPool<T> avgPool(Operand<T> value, List<Long> ksize,
+  public <T extends TNumber> AvgPool<T> avgPool(Operand<T> value, List<Long> ksize,
       List<Long> strides, String padding, AvgPool.Options... options) {
     return AvgPool.create(scope, value, ksize, strides, padding, options);
   }
@@ -140,7 +140,7 @@ public <T extends Tensor & TNumber> AvgPool<T> avgPool(Operand<T> value, List<Lo
    * @param options carries optional attributes values
    * @return a new instance of AvgPool3d
    */
-  public <T extends Tensor & TNumber> AvgPool3d<T> avgPool3d(Operand<T> input, List<Long> ksize,
+  public <T extends TNumber> AvgPool3d<T> avgPool3d(Operand<T> input, List<Long> ksize,
       List<Long> strides, String padding, AvgPool3d.Options... options) {
     return AvgPool3d.create(scope, input, ksize, strides, padding, options);
   }
@@ -159,7 +159,7 @@ public <T extends Tensor & TNumber> AvgPool3d<T> avgPool3d(Operand<T> input, Lis
    * @param options carries optional attributes values
    * @return a new instance of AvgPool3dGrad
    */
-  public <T extends Tensor & TNumber> AvgPool3dGrad<T> avgPool3dGrad(Operand<TInt32> origInputShape,
+  public <T extends TNumber> AvgPool3dGrad<T> avgPool3dGrad(Operand<TInt32> origInputShape,
       Operand<T> grad, List<Long> ksize, List<Long> strides, String padding,
       AvgPool3dGrad.Options... options) {
     return AvgPool3dGrad.create(scope, origInputShape, grad, ksize, strides, padding, options);
@@ -188,7 +188,7 @@ public <T extends Tensor & TNumber> AvgPool3dGrad<T> avgPool3dGrad(Operand<TInt3
    *  needs to be multiplied with gamma.
    * @return a new instance of BatchNormWithGlobalNormalization
    */
-  public <T extends Tensor> BatchNormWithGlobalNormalization<T> batchNormWithGlobalNormalization(
+  public <T extends TType> BatchNormWithGlobalNormalization<T> batchNormWithGlobalNormalization(
       Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> beta, Operand<T> gamma,
       Float varianceEpsilon, Boolean scaleAfterNormalization) {
     return BatchNormWithGlobalNormalization.create(scope, t, m, v, beta, gamma, varianceEpsilon, scaleAfterNormalization);
@@ -216,7 +216,7 @@ public <T extends Tensor> BatchNormWithGlobalNormalization<T> batchNormWithGloba
    *  needs to be multiplied with gamma.
    * @return a new instance of BatchNormWithGlobalNormalizationGrad
    */
-  public <T extends Tensor> BatchNormWithGlobalNormalizationGrad<T> batchNormWithGlobalNormalizationGrad(
+  public <T extends TType> BatchNormWithGlobalNormalizationGrad<T> batchNormWithGlobalNormalizationGrad(
       Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> gamma, Operand<T> backprop,
       Float varianceEpsilon, Boolean scaleAfterNormalization) {
     return BatchNormWithGlobalNormalizationGrad.create(scope, t, m, v, gamma, backprop, varianceEpsilon, scaleAfterNormalization);
@@ -234,7 +234,7 @@ public <T extends Tensor> BatchNormWithGlobalNormalizationGrad<T> batchNormWithG
    * @param options carries optional attributes values
    * @return a new instance of BiasAdd
    */
-  public <T extends Tensor> BiasAdd<T> biasAdd(Operand<T> value, Operand<T> bias,
+  public <T extends TType> BiasAdd<T> biasAdd(Operand<T> value, Operand<T> bias,
       BiasAdd.Options... options) {
     return BiasAdd.create(scope, value, bias, options);
   }
@@ -251,7 +251,7 @@ public <T extends Tensor> BiasAdd<T> biasAdd(Operand<T> value, Operand<T> bias,
    * @param options carries optional attributes values
    * @return a new instance of BiasAddGrad
    */
-  public <T extends Tensor> BiasAddGrad<T> biasAddGrad(Operand<T> outBackprop,
+  public <T extends TType> BiasAddGrad<T> biasAddGrad(Operand<T> outBackprop,
       BiasAddGrad.Options... options) {
     return BiasAddGrad.create(scope, outBackprop, options);
   }
@@ -312,7 +312,7 @@ public ComputeAccidentalHits computeAccidentalHits(Operand<TInt64> trueClasses,
    * @param options carries optional attributes values
    * @return a new instance of Conv2d
    */
-  public <T extends Tensor & TNumber> Conv2d<T> conv2d(Operand<T> input, Operand<T> filter,
+  public <T extends TNumber> Conv2d<T> conv2d(Operand<T> input, Operand<T> filter,
       List<Long> strides, String padding, Conv2d.Options... options) {
     return Conv2d.create(scope, input, filter, strides, padding, options);
   }
@@ -334,7 +334,7 @@ public <T extends Tensor & TNumber> Conv2d<T> conv2d(Operand<T> input, Operand<T
    * @param options carries optional attributes values
    * @return a new instance of Conv2dBackpropFilter
    */
-  public <T extends Tensor & TNumber> Conv2dBackpropFilter<T> conv2dBackpropFilter(Operand<T> input,
+  public <T extends TNumber> Conv2dBackpropFilter<T> conv2dBackpropFilter(Operand<T> input,
       Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding,
       Conv2dBackpropFilter.Options... options) {
     return Conv2dBackpropFilter.create(scope, input, filterSizes, outBackprop, strides, padding, options);
@@ -357,9 +357,9 @@ public <T extends Tensor & TNumber> Conv2dBackpropFilter<T> conv2dBackpropFilter
    * @param options carries optional attributes values
    * @return a new instance of Conv2dBackpropInput
    */
-  public <T extends Tensor & TNumber> Conv2dBackpropInput<T> conv2dBackpropInput(
-      Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
-      String padding, Conv2dBackpropInput.Options... options) {
+  public <T extends TNumber> Conv2dBackpropInput<T> conv2dBackpropInput(Operand<TInt32> inputSizes,
+      Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding,
+      Conv2dBackpropInput.Options... options) {
     return Conv2dBackpropInput.create(scope, inputSizes, filter, outBackprop, strides, padding, options);
   }
 
@@ -382,7 +382,7 @@ public <T extends Tensor & TNumber> Conv2dBackpropInput<T> conv2dBackpropInput(
    * @param options carries optional attributes values
    * @return a new instance of Conv3d
    */
-  public <T extends Tensor & TNumber> Conv3d<T> conv3d(Operand<T> input, Operand<T> filter,
+  public <T extends TNumber> Conv3d<T> conv3d(Operand<T> input, Operand<T> filter,
       List<Long> strides, String padding, Conv3d.Options... options) {
     return Conv3d.create(scope, input, filter, strides, padding, options);
   }
@@ -404,7 +404,7 @@ public <T extends Tensor & TNumber> Conv3d<T> conv3d(Operand<T> input, Operand<T
    * @param options carries optional attributes values
    * @return a new instance of Conv3dBackpropFilter
    */
-  public <T extends Tensor & TNumber> Conv3dBackpropFilter<T> conv3dBackpropFilter(Operand<T> input,
+  public <T extends TNumber> Conv3dBackpropFilter<T> conv3dBackpropFilter(Operand<T> input,
       Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding,
       Conv3dBackpropFilter.Options... options) {
     return Conv3dBackpropFilter.create(scope, input, filterSizes, outBackprop, strides, padding, options);
@@ -427,7 +427,7 @@ public <T extends Tensor & TNumber> Conv3dBackpropFilter<T> conv3dBackpropFilter
    * @param options carries optional attributes values
    * @return a new instance of Conv3dBackpropInput
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> Conv3dBackpropInput<U> conv3dBackpropInput(
+  public <U extends TNumber, T extends TNumber> Conv3dBackpropInput<U> conv3dBackpropInput(
       Operand<T> inputSizes, Operand<U> filter, Operand<U> outBackprop, List<Long> strides,
       String padding, Conv3dBackpropInput.Options... options) {
     return Conv3dBackpropInput.create(scope, inputSizes, filter, outBackprop, strides, padding, options);
@@ -450,8 +450,8 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> Conv3dBackpropIn
    * @param options carries optional attributes values
    * @return a new instance of CtcBeamSearchDecoder
    */
-  public <T extends Tensor & TNumber> CtcBeamSearchDecoder<T> ctcBeamSearchDecoder(
-      Operand<T> inputs, Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths,
+  public <T extends TNumber> CtcBeamSearchDecoder<T> ctcBeamSearchDecoder(Operand<T> inputs,
+      Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths,
       CtcBeamSearchDecoder.Options... options) {
     return CtcBeamSearchDecoder.create(scope, inputs, sequenceLength, beamWidth, topPaths, options);
   }
@@ -475,7 +475,7 @@ public <T extends Tensor & TNumber> CtcBeamSearchDecoder<T> ctcBeamSearchDecoder
    * @param options carries optional attributes values
    * @return a new instance of CtcGreedyDecoder
    */
-  public <T extends Tensor & TNumber> CtcGreedyDecoder<T> ctcGreedyDecoder(Operand<T> inputs,
+  public <T extends TNumber> CtcGreedyDecoder<T> ctcGreedyDecoder(Operand<T> inputs,
       Operand<TInt32> sequenceLength, CtcGreedyDecoder.Options... options) {
     return CtcGreedyDecoder.create(scope, inputs, sequenceLength, options);
   }
@@ -496,9 +496,8 @@ public <T extends Tensor & TNumber> CtcGreedyDecoder<T> ctcGreedyDecoder(Operand
    * @param options carries optional attributes values
    * @return a new instance of CtcLoss
    */
-  public <T extends Tensor & TNumber> CtcLoss<T> ctcLoss(Operand<T> inputs,
-      Operand<TInt64> labelsIndices, Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength,
-      CtcLoss.Options... options) {
+  public <T extends TNumber> CtcLoss<T> ctcLoss(Operand<T> inputs, Operand<TInt64> labelsIndices,
+      Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength, CtcLoss.Options... options) {
     return CtcLoss.create(scope, inputs, labelsIndices, labelsValues, sequenceLength, options);
   }
 
@@ -545,7 +544,7 @@ public <T extends Tensor & TNumber> CtcLoss<T> ctcLoss(Operand<T> inputs,
    * @param options carries optional attributes values
    * @return a new instance of CudnnRNNCanonicalToParams
    */
-  public <T extends Tensor & TNumber> CudnnRNNCanonicalToParams<T> cudnnRNNCanonicalToParams(
+  public <T extends TNumber> CudnnRNNCanonicalToParams<T> cudnnRNNCanonicalToParams(
       Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize,
       Iterable<Operand<T>> weights, Iterable<Operand<T>> biases,
       CudnnRNNCanonicalToParams.Options... options) {
@@ -596,7 +595,7 @@ public <T extends Tensor & TNumber> CudnnRNNCanonicalToParams<T> cudnnRNNCanonic
    * @param options carries optional attributes values
    * @return a new instance of CudnnRNNParamsToCanonical
    */
-  public <T extends Tensor & TNumber> CudnnRNNParamsToCanonical<T> cudnnRNNParamsToCanonical(
+  public <T extends TNumber> CudnnRNNParamsToCanonical<T> cudnnRNNParamsToCanonical(
       Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize,
       Operand<T> params, Long numParamsWeights, Long numParamsBiases,
       CudnnRNNParamsToCanonical.Options... options) {
@@ -637,7 +636,7 @@ public <T extends Tensor & TNumber> CudnnRNNParamsToCanonical<T> cudnnRNNParamsT
    * @param options carries optional attributes values
    * @return a new instance of CudnnRnnParamsSize
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> CudnnRnnParamsSize<U> cudnnRnnParamsSize(
+  public <U extends TNumber, T extends TNumber> CudnnRnnParamsSize<U> cudnnRnnParamsSize(
       Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, DataType<T> T,
       DataType<U> S, CudnnRnnParamsSize.Options... options) {
     return CudnnRnnParamsSize.create(scope, numLayers, numUnits, inputSize, T, S, options);
@@ -654,7 +653,7 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> CudnnRnnParamsSi
    * @param options carries optional attributes values
    * @return a new instance of DataFormatDimMap
    */
-  public <T extends Tensor & TNumber> DataFormatDimMap<T> dataFormatDimMap(Operand<T> x,
+  public <T extends TNumber> DataFormatDimMap<T> dataFormatDimMap(Operand<T> x,
       DataFormatDimMap.Options... options) {
     return DataFormatDimMap.create(scope, x, options);
   }
@@ -669,7 +668,7 @@ public <T extends Tensor & TNumber> DataFormatDimMap<T> dataFormatDimMap(Operand
    * @param options carries optional attributes values
    * @return a new instance of DataFormatVecPermute
    */
-  public <T extends Tensor & TNumber> DataFormatVecPermute<T> dataFormatVecPermute(Operand<T> x,
+  public <T extends TNumber> DataFormatVecPermute<T> dataFormatVecPermute(Operand<T> x,
       DataFormatVecPermute.Options... options) {
     return DataFormatVecPermute.create(scope, x, options);
   }
@@ -762,7 +761,7 @@ public <T extends Tensor & TNumber> DataFormatVecPermute<T> dataFormatVecPermute
    * @param options carries optional attributes values
    * @return a new instance of DepthToSpace
    */
-  public <T extends Tensor> DepthToSpace<T> depthToSpace(Operand<T> input, Long blockSize,
+  public <T extends TType> DepthToSpace<T> depthToSpace(Operand<T> input, Long blockSize,
       DepthToSpace.Options... options) {
     return DepthToSpace.create(scope, input, blockSize, options);
   }
@@ -796,8 +795,8 @@ public <T extends Tensor> DepthToSpace<T> depthToSpace(Operand<T> input, Long bl
    * @param options carries optional attributes values
    * @return a new instance of DepthwiseConv2dNative
    */
-  public <T extends Tensor & TNumber> DepthwiseConv2dNative<T> depthwiseConv2dNative(
-      Operand<T> input, Operand<T> filter, List<Long> strides, String padding,
+  public <T extends TNumber> DepthwiseConv2dNative<T> depthwiseConv2dNative(Operand<T> input,
+      Operand<T> filter, List<Long> strides, String padding,
       DepthwiseConv2dNative.Options... options) {
     return DepthwiseConv2dNative.create(scope, input, filter, strides, padding, options);
   }
@@ -822,7 +821,7 @@ public <T extends Tensor & TNumber> DepthwiseConv2dNative<T> depthwiseConv2dNati
    * @param options carries optional attributes values
    * @return a new instance of DepthwiseConv2dNativeBackpropFilter
    */
-  public <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropFilter<T> depthwiseConv2dNativeBackpropFilter(
+  public <T extends TNumber> DepthwiseConv2dNativeBackpropFilter<T> depthwiseConv2dNativeBackpropFilter(
       Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides,
       String padding, DepthwiseConv2dNativeBackpropFilter.Options... options) {
     return DepthwiseConv2dNativeBackpropFilter.create(scope, input, filterSizes, outBackprop, strides, padding, options);
@@ -847,7 +846,7 @@ public <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropFilter<T> depth
    * @param options carries optional attributes values
    * @return a new instance of DepthwiseConv2dNativeBackpropInput
    */
-  public <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropInput<T> depthwiseConv2dNativeBackpropInput(
+  public <T extends TNumber> DepthwiseConv2dNativeBackpropInput<T> depthwiseConv2dNativeBackpropInput(
       Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
       String padding, DepthwiseConv2dNativeBackpropInput.Options... options) {
     return DepthwiseConv2dNativeBackpropInput.create(scope, inputSizes, filter, outBackprop, strides, padding, options);
@@ -890,7 +889,7 @@ public <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropInput<T> depthw
    * @param padding The type of padding algorithm to use.
    * @return a new instance of Dilation2d
    */
-  public <T extends Tensor & TNumber> Dilation2d<T> dilation2d(Operand<T> input, Operand<T> filter,
+  public <T extends TNumber> Dilation2d<T> dilation2d(Operand<T> input, Operand<T> filter,
       List<Long> strides, List<Long> rates, String padding) {
     return Dilation2d.create(scope, input, filter, strides, rates, padding);
   }
@@ -909,9 +908,9 @@ public <T extends Tensor & TNumber> Dilation2d<T> dilation2d(Operand<T> input, O
    * @param padding The type of padding algorithm to use.
    * @return a new instance of Dilation2dBackpropFilter
    */
-  public <T extends Tensor & TNumber> Dilation2dBackpropFilter<T> dilation2dBackpropFilter(
-      Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
-      List<Long> rates, String padding) {
+  public <T extends TNumber> Dilation2dBackpropFilter<T> dilation2dBackpropFilter(Operand<T> input,
+      Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates,
+      String padding) {
     return Dilation2dBackpropFilter.create(scope, input, filter, outBackprop, strides, rates, padding);
   }
 
@@ -929,9 +928,9 @@ public <T extends Tensor & TNumber> Dilation2dBackpropFilter<T> dilation2dBackpr
    * @param padding The type of padding algorithm to use.
    * @return a new instance of Dilation2dBackpropInput
    */
-  public <T extends Tensor & TNumber> Dilation2dBackpropInput<T> dilation2dBackpropInput(
-      Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides,
-      List<Long> rates, String padding) {
+  public <T extends TNumber> Dilation2dBackpropInput<T> dilation2dBackpropInput(Operand<T> input,
+      Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates,
+      String padding) {
     return Dilation2dBackpropInput.create(scope, input, filter, outBackprop, strides, rates, padding);
   }
 
@@ -945,7 +944,7 @@ public <T extends Tensor & TNumber> Dilation2dBackpropInput<T> dilation2dBackpro
    * @param features
    * @return a new instance of Elu
    */
-  public <T extends Tensor & TNumber> Elu<T> elu(Operand<T> features) {
+  public <T extends TNumber> Elu<T> elu(Operand<T> features) {
     return Elu.create(scope, features);
   }
 
@@ -1003,7 +1002,7 @@ public FixedUnigramCandidateSampler fixedUnigramCandidateSampler(Operand<TInt64>
    * @param options carries optional attributes values
    * @return a new instance of FractionalAvgPool
    */
-  public <T extends Tensor & TNumber> FractionalAvgPool<T> fractionalAvgPool(Operand<T> value,
+  public <T extends TNumber> FractionalAvgPool<T> fractionalAvgPool(Operand<T> value,
       List<Float> poolingRatio, FractionalAvgPool.Options... options) {
     return FractionalAvgPool.create(scope, value, poolingRatio, options);
   }
@@ -1051,7 +1050,7 @@ public <T extends Tensor & TNumber> FractionalAvgPool<T> fractionalAvgPool(Opera
    * @param options carries optional attributes values
    * @return a new instance of FractionalMaxPool
    */
-  public <T extends Tensor & TNumber> FractionalMaxPool<T> fractionalMaxPool(Operand<T> value,
+  public <T extends TNumber> FractionalMaxPool<T> fractionalMaxPool(Operand<T> value,
       List<Float> poolingRatio, FractionalMaxPool.Options... options) {
     return FractionalMaxPool.create(scope, value, poolingRatio, options);
   }
@@ -1074,8 +1073,8 @@ public <T extends Tensor & TNumber> FractionalMaxPool<T> fractionalMaxPool(Opera
    * @param options carries optional attributes values
    * @return a new instance of FusedBatchNorm
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNorm<T, U> fusedBatchNorm(
-      Operand<T> x, Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance,
+  public <T extends TNumber, U extends TNumber> FusedBatchNorm<T, U> fusedBatchNorm(Operand<T> x,
+      Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance,
       FusedBatchNorm.Options... options) {
     return FusedBatchNorm.create(scope, x, scale, offset, mean, variance, options);
   }
@@ -1106,7 +1105,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNorm<T
    * @param options carries optional attributes values
    * @return a new instance of FusedBatchNormGrad
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNormGrad<T, U> fusedBatchNormGrad(
+  public <T extends TNumber, U extends TNumber> FusedBatchNormGrad<T, U> fusedBatchNormGrad(
       Operand<T> yBackprop, Operand<T> x, Operand<TFloat32> scale, Operand<U> reserveSpace1,
       Operand<U> reserveSpace2, Operand<U> reserveSpace3, FusedBatchNormGrad.Options... options) {
     return FusedBatchNormGrad.create(scope, yBackprop, x, scale, reserveSpace1, reserveSpace2, reserveSpace3, options);
@@ -1139,7 +1138,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNormGr
    * @param padding The type of padding algorithm to use.
    * @return a new instance of FusedPadConv2d
    */
-  public <T extends Tensor & TNumber> FusedPadConv2d<T> fusedPadConv2d(Operand<T> input,
+  public <T extends TNumber> FusedPadConv2d<T> fusedPadConv2d(Operand<T> input,
       Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides,
       String padding) {
     return FusedPadConv2d.create(scope, input, paddings, filter, mode, strides, padding);
@@ -1174,9 +1173,9 @@ public <T extends Tensor & TNumber> FusedPadConv2d<T> fusedPadConv2d(Operand<T>
    * @param options carries optional attributes values
    * @return a new instance of FusedResizeAndPadConv2d
    */
-  public <T extends Tensor & TNumber> FusedResizeAndPadConv2d<T> fusedResizeAndPadConv2d(
-      Operand<T> input, Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter,
-      String mode, List<Long> strides, String padding, FusedResizeAndPadConv2d.Options... options) {
+  public <T extends TNumber> FusedResizeAndPadConv2d<T> fusedResizeAndPadConv2d(Operand<T> input,
+      Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter, String mode,
+      List<Long> strides, String padding, FusedResizeAndPadConv2d.Options... options) {
     return FusedResizeAndPadConv2d.create(scope, input, size, paddings, filter, mode, strides, padding, options);
   }
 
@@ -1203,8 +1202,8 @@ public <T extends Tensor & TNumber> FusedResizeAndPadConv2d<T> fusedResizeAndPad
    * @param k Number of top elements to look at for computing precision.
    * @return a new instance of InTopK
    */
-  public <T extends Tensor & TNumber> InTopK inTopK(Operand<TFloat32> predictions,
-      Operand<T> targets, Operand<T> k) {
+  public <T extends TNumber> InTopK inTopK(Operand<TFloat32> predictions, Operand<T> targets,
+      Operand<T> k) {
     return InTopK.create(scope, predictions, targets, k);
   }
 
@@ -1219,7 +1218,7 @@ public <T extends Tensor & TNumber> InTopK inTopK(Operand<TFloat32> predictions,
    * @param t Typically 2-D, but may have any dimensions.
    * @return a new instance of L2Loss
    */
-  public <T extends Tensor & TNumber> L2Loss<T> l2Loss(Operand<T> t) {
+  public <T extends TNumber> L2Loss<T> l2Loss(Operand<T> t) {
     return L2Loss.create(scope, t);
   }
 
@@ -1273,7 +1272,7 @@ public LearnedUnigramCandidateSampler learnedUnigramCandidateSampler(Operand<TIn
    * @param options carries optional attributes values
    * @return a new instance of LocalResponseNormalization
    */
-  public <T extends Tensor & TNumber> LocalResponseNormalization<T> localResponseNormalization(
+  public <T extends TNumber> LocalResponseNormalization<T> localResponseNormalization(
       Operand<T> input, LocalResponseNormalization.Options... options) {
     return LocalResponseNormalization.create(scope, input, options);
   }
@@ -1289,7 +1288,7 @@ public <T extends Tensor & TNumber> LocalResponseNormalization<T> localResponseN
    * @param logits 2-D with shape `[batch_size, num_classes]`.
    * @return a new instance of LogSoftmax
    */
-  public <T extends Tensor & TNumber> LogSoftmax<T> logSoftmax(Operand<T> logits) {
+  public <T extends TNumber> LogSoftmax<T> logSoftmax(Operand<T> logits) {
     return LogSoftmax.create(scope, logits);
   }
 
@@ -1305,7 +1304,7 @@ public <T extends Tensor & TNumber> LogSoftmax<T> logSoftmax(Operand<T> logits)
    * @param options carries optional attributes values
    * @return a new instance of MaxPool
    */
-  public <T extends Tensor> MaxPool<T> maxPool(Operand<T> input, Operand<TInt32> ksize,
+  public <T extends TType> MaxPool<T> maxPool(Operand<T> input, Operand<TInt32> ksize,
       Operand<TInt32> strides, String padding, MaxPool.Options... options) {
     return MaxPool.create(scope, input, ksize, strides, padding, options);
   }
@@ -1323,7 +1322,7 @@ public <T extends Tensor> MaxPool<T> maxPool(Operand<T> input, Operand<TInt32> k
    * @param options carries optional attributes values
    * @return a new instance of MaxPool3d
    */
-  public <T extends Tensor & TNumber> MaxPool3d<T> maxPool3d(Operand<T> input, List<Long> ksize,
+  public <T extends TNumber> MaxPool3d<T> maxPool3d(Operand<T> input, List<Long> ksize,
       List<Long> strides, String padding, MaxPool3d.Options... options) {
     return MaxPool3d.create(scope, input, ksize, strides, padding, options);
   }
@@ -1343,9 +1342,9 @@ public <T extends Tensor & TNumber> MaxPool3d<T> maxPool3d(Operand<T> input, Lis
    * @param options carries optional attributes values
    * @return a new instance of MaxPool3dGrad
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> MaxPool3dGrad<U> maxPool3dGrad(
-      Operand<T> origInput, Operand<T> origOutput, Operand<U> grad, List<Long> ksize,
-      List<Long> strides, String padding, MaxPool3dGrad.Options... options) {
+  public <U extends TNumber, T extends TNumber> MaxPool3dGrad<U> maxPool3dGrad(Operand<T> origInput,
+      Operand<T> origOutput, Operand<U> grad, List<Long> ksize, List<Long> strides, String padding,
+      MaxPool3dGrad.Options... options) {
     return MaxPool3dGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
   }
 
@@ -1364,7 +1363,7 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> MaxPool3dGrad<U>
    * @param options carries optional attributes values
    * @return a new instance of MaxPool3dGradGrad
    */
-  public <T extends Tensor & TNumber> MaxPool3dGradGrad<T> maxPool3dGradGrad(Operand<T> origInput,
+  public <T extends TNumber> MaxPool3dGradGrad<T> maxPool3dGradGrad(Operand<T> origInput,
       Operand<T> origOutput, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding,
       MaxPool3dGradGrad.Options... options) {
     return MaxPool3dGradGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
@@ -1384,9 +1383,9 @@ public <T extends Tensor & TNumber> MaxPool3dGradGrad<T> maxPool3dGradGrad(Opera
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolGrad
    */
-  public <T extends Tensor & TNumber> MaxPoolGrad<T> maxPoolGrad(Operand<T> origInput,
-      Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides,
-      String padding, MaxPoolGrad.Options... options) {
+  public <T extends TNumber> MaxPoolGrad<T> maxPoolGrad(Operand<T> origInput, Operand<T> origOutput,
+      Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding,
+      MaxPoolGrad.Options... options) {
     return MaxPoolGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
   }
 
@@ -1404,7 +1403,7 @@ public <T extends Tensor & TNumber> MaxPoolGrad<T> maxPoolGrad(Operand<T> origIn
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolGradGrad
    */
-  public <T extends Tensor & TNumber> MaxPoolGradGrad<T> maxPoolGradGrad(Operand<T> origInput,
+  public <T extends TNumber> MaxPoolGradGrad<T> maxPoolGradGrad(Operand<T> origInput,
       Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides,
       String padding, MaxPoolGradGrad.Options... options) {
     return MaxPoolGradGrad.create(scope, origInput, origOutput, grad, ksize, strides, padding, options);
@@ -1425,7 +1424,7 @@ public <T extends Tensor & TNumber> MaxPoolGradGrad<T> maxPoolGradGrad(Operand<T
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolGradGradWithArgmax
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolGradGradWithArgmax<T> maxPoolGradGradWithArgmax(
+  public <T extends TNumber, U extends TNumber> MaxPoolGradGradWithArgmax<T> maxPoolGradGradWithArgmax(
       Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides,
       String padding, MaxPoolGradGradWithArgmax.Options... options) {
     return MaxPoolGradGradWithArgmax.create(scope, input, grad, argmax, ksize, strides, padding, options);
@@ -1454,9 +1453,8 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolGradGradW
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolWithArgmax
    */
-  public <T extends Tensor & TNumber> MaxPoolWithArgmax<T, TInt64> maxPoolWithArgmax(
-      Operand<T> input, List<Long> ksize, List<Long> strides, String padding,
-      MaxPoolWithArgmax.Options... options) {
+  public <T extends TNumber> MaxPoolWithArgmax<T, TInt64> maxPoolWithArgmax(Operand<T> input,
+      List<Long> ksize, List<Long> strides, String padding, MaxPoolWithArgmax.Options... options) {
     return MaxPoolWithArgmax.create(scope, input, ksize, strides, padding, options);
   }
 
@@ -1484,7 +1482,7 @@ public <T extends Tensor & TNumber> MaxPoolWithArgmax<T, TInt64> maxPoolWithArgm
    * @param options carries optional attributes values
    * @return a new instance of MaxPoolWithArgmax
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolWithArgmax<T, U> maxPoolWithArgmax(
+  public <T extends TNumber, U extends TNumber> MaxPoolWithArgmax<T, U> maxPoolWithArgmax(
       Operand<T> input, List<Long> ksize, List<Long> strides, DataType<U> Targmax, String padding,
       MaxPoolWithArgmax.Options... options) {
     return MaxPoolWithArgmax.create(scope, input, ksize, strides, Targmax, padding, options);
@@ -1508,7 +1506,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolWithArgma
    * @param options carries optional attributes values
    * @return a new instance of NthElement
    */
-  public <T extends Tensor & TNumber> NthElement<T> nthElement(Operand<T> input, Operand<TInt32> n,
+  public <T extends TNumber> NthElement<T> nthElement(Operand<T> input, Operand<TInt32> n,
       NthElement.Options... options) {
     return NthElement.create(scope, input, n, options);
   }
@@ -1527,7 +1525,7 @@ public <T extends Tensor & TNumber> NthElement<T> nthElement(Operand<T> input, O
    * @param padding The type of padding algorithm to use.
    * @return a new instance of QuantizedAvgPool
    */
-  public <T extends Tensor> QuantizedAvgPool<T> quantizedAvgPool(Operand<T> input,
+  public <T extends TType> QuantizedAvgPool<T> quantizedAvgPool(Operand<T> input,
       Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides,
       String padding) {
     return QuantizedAvgPool.create(scope, input, minInput, maxInput, ksize, strides, padding);
@@ -1568,7 +1566,7 @@ public <T extends Tensor> QuantizedAvgPool<T> quantizedAvgPool(Operand<T> input,
    *  needs to be multiplied with gamma.
    * @return a new instance of QuantizedBatchNormWithGlobalNormalization
    */
-  public <U extends Tensor, T extends Tensor> QuantizedBatchNormWithGlobalNormalization<U> quantizedBatchNormWithGlobalNormalization(
+  public <U extends TType, T extends TType> QuantizedBatchNormWithGlobalNormalization<U> quantizedBatchNormWithGlobalNormalization(
       Operand<T> t, Operand<TFloat32> tMin, Operand<TFloat32> tMax, Operand<T> m,
       Operand<TFloat32> mMin, Operand<TFloat32> mMax, Operand<T> v, Operand<TFloat32> vMin,
       Operand<TFloat32> vMax, Operand<T> beta, Operand<TFloat32> betaMin, Operand<TFloat32> betaMax,
@@ -1592,7 +1590,7 @@ public <U extends Tensor, T extends Tensor> QuantizedBatchNormWithGlobalNormaliz
    * @param outType
    * @return a new instance of QuantizedBiasAdd
    */
-  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedBiasAdd<V> quantizedBiasAdd(
+  public <V extends TType, T extends TType, U extends TType> QuantizedBiasAdd<V> quantizedBiasAdd(
       Operand<T> input, Operand<U> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput,
       Operand<TFloat32> minBias, Operand<TFloat32> maxBias, DataType<V> outType) {
     return QuantizedBiasAdd.create(scope, input, bias, minInput, maxInput, minBias, maxBias, outType);
@@ -1620,7 +1618,7 @@ public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedBiasAdd<V
    * @param options carries optional attributes values
    * @return a new instance of QuantizedConv2d
    */
-  public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2d<V> quantizedConv2d(
+  public <V extends TType, T extends TType, U extends TType> QuantizedConv2d<V> quantizedConv2d(
       Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput,
       Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType,
       List<Long> strides, String padding, QuantizedConv2d.Options... options) {
@@ -1637,7 +1635,7 @@ public <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2d<V>
    * @param options carries optional attributes values
    * @return a new instance of QuantizedInstanceNorm
    */
-  public <T extends Tensor> QuantizedInstanceNorm<T> quantizedInstanceNorm(Operand<T> x,
+  public <T extends TType> QuantizedInstanceNorm<T> quantizedInstanceNorm(Operand<T> x,
       Operand<TFloat32> xMin, Operand<TFloat32> xMax, QuantizedInstanceNorm.Options... options) {
     return QuantizedInstanceNorm.create(scope, x, xMin, xMax, options);
   }
@@ -1656,7 +1654,7 @@ public <T extends Tensor> QuantizedInstanceNorm<T> quantizedInstanceNorm(Operand
    * @param padding The type of padding algorithm to use.
    * @return a new instance of QuantizedMaxPool
    */
-  public <T extends Tensor> QuantizedMaxPool<T> quantizedMaxPool(Operand<T> input,
+  public <T extends TType> QuantizedMaxPool<T> quantizedMaxPool(Operand<T> input,
       Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides,
       String padding) {
     return QuantizedMaxPool.create(scope, input, minInput, maxInput, ksize, strides, padding);
@@ -1672,7 +1670,7 @@ public <T extends Tensor> QuantizedMaxPool<T> quantizedMaxPool(Operand<T> input,
    * @param outType
    * @return a new instance of QuantizedRelu
    */
-  public <U extends Tensor, T extends Tensor> QuantizedRelu<U> quantizedRelu(Operand<T> features,
+  public <U extends TType, T extends TType> QuantizedRelu<U> quantizedRelu(Operand<T> features,
       Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     return QuantizedRelu.create(scope, features, minFeatures, maxFeatures, outType);
   }
@@ -1687,7 +1685,7 @@ public <U extends Tensor, T extends Tensor> QuantizedRelu<U> quantizedRelu(Opera
    * @param outType
    * @return a new instance of QuantizedRelu6
    */
-  public <U extends Tensor, T extends Tensor> QuantizedRelu6<U> quantizedRelu6(Operand<T> features,
+  public <U extends TType, T extends TType> QuantizedRelu6<U> quantizedRelu6(Operand<T> features,
       Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     return QuantizedRelu6.create(scope, features, minFeatures, maxFeatures, outType);
   }
@@ -1703,7 +1701,7 @@ public <U extends Tensor, T extends Tensor> QuantizedRelu6<U> quantizedRelu6(Ope
    * @param outType
    * @return a new instance of QuantizedReluX
    */
-  public <U extends Tensor, T extends Tensor> QuantizedReluX<U> quantizedReluX(Operand<T> features,
+  public <U extends TType, T extends TType> QuantizedReluX<U> quantizedReluX(Operand<T> features,
       Operand<TFloat32> maxValue, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures,
       DataType<U> outType) {
     return QuantizedReluX.create(scope, features, maxValue, minFeatures, maxFeatures, outType);
@@ -1721,7 +1719,7 @@ public <U extends Tensor, T extends Tensor> QuantizedReluX<U> quantizedReluX(Ope
    * @param features
    * @return a new instance of Relu
    */
-  public <T extends Tensor> Relu<T> relu(Operand<T> features) {
+  public <T extends TType> Relu<T> relu(Operand<T> features) {
     return Relu.create(scope, features);
   }
 
@@ -1732,7 +1730,7 @@ public <T extends Tensor> Relu<T> relu(Operand<T> features) {
    * @param features
    * @return a new instance of Relu6
    */
-  public <T extends Tensor & TNumber> Relu6<T> relu6(Operand<T> features) {
+  public <T extends TNumber> Relu6<T> relu6(Operand<T> features) {
     return Relu6.create(scope, features);
   }
 
@@ -1751,7 +1749,7 @@ public <T extends Tensor & TNumber> Relu6<T> relu6(Operand<T> features) {
    * @param features
    * @return a new instance of Selu
    */
-  public <T extends Tensor & TNumber> Selu<T> selu(Operand<T> features) {
+  public <T extends TNumber> Selu<T> selu(Operand<T> features) {
     return Selu.create(scope, features);
   }
 
@@ -1766,7 +1764,7 @@ public <T extends Tensor & TNumber> Selu<T> selu(Operand<T> features) {
    * @param logits 2-D with shape `[batch_size, num_classes]`.
    * @return a new instance of Softmax
    */
-  public <T extends Tensor & TNumber> Softmax<T> softmax(Operand<T> logits) {
+  public <T extends TNumber> Softmax<T> softmax(Operand<T> logits) {
     return Softmax.create(scope, logits);
   }
 
@@ -1782,7 +1780,7 @@ public <T extends Tensor & TNumber> Softmax<T> softmax(Operand<T> logits) {
    *  probability distribution.
    * @return a new instance of SoftmaxCrossEntropyWithLogits
    */
-  public <T extends Tensor & TNumber> SoftmaxCrossEntropyWithLogits<T> softmaxCrossEntropyWithLogits(
+  public <T extends TNumber> SoftmaxCrossEntropyWithLogits<T> softmaxCrossEntropyWithLogits(
       Operand<T> features, Operand<T> labels) {
     return SoftmaxCrossEntropyWithLogits.create(scope, features, labels);
   }
@@ -1794,7 +1792,7 @@ public <T extends Tensor & TNumber> SoftmaxCrossEntropyWithLogits<T> softmaxCros
    * @param features
    * @return a new instance of Softsign
    */
-  public <T extends Tensor & TNumber> Softsign<T> softsign(Operand<T> features) {
+  public <T extends TNumber> Softsign<T> softsign(Operand<T> features) {
     return Softsign.create(scope, features);
   }
 
@@ -1883,8 +1881,8 @@ public <T extends Tensor & TNumber> Softsign<T> softsign(Operand<T> features) {
    * @param blockSize
    * @return a new instance of SpaceToBatch
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SpaceToBatch<T> spaceToBatch(
-      Operand<T> input, Operand<U> paddings, Long blockSize) {
+  public <T extends TType, U extends TNumber> SpaceToBatch<T> spaceToBatch(Operand<T> input,
+      Operand<U> paddings, Long blockSize) {
     return SpaceToBatch.create(scope, input, paddings, blockSize);
   }
 
@@ -1970,7 +1968,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SpaceToBatch<T> spaceToBat
    * @param options carries optional attributes values
    * @return a new instance of SpaceToDepth
    */
-  public <T extends Tensor> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long blockSize,
+  public <T extends TType> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long blockSize,
       SpaceToDepth.Options... options) {
     return SpaceToDepth.create(scope, input, blockSize, options);
   }
@@ -1991,7 +1989,7 @@ public <T extends Tensor> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long bl
    *  This is the label for the given minibatch entry.
    * @return a new instance of SparseSoftmaxCrossEntropyWithLogits
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSoftmaxCrossEntropyWithLogits<T> sparseSoftmaxCrossEntropyWithLogits(
+  public <T extends TNumber, U extends TNumber> SparseSoftmaxCrossEntropyWithLogits<T> sparseSoftmaxCrossEntropyWithLogits(
       Operand<T> features, Operand<U> labels) {
     return SparseSoftmaxCrossEntropyWithLogits.create(scope, features, labels);
   }
@@ -2017,7 +2015,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSoftmaxCro
    * @param options carries optional attributes values
    * @return a new instance of TopK
    */
-  public <T extends Tensor & TNumber> TopK<T> topK(Operand<T> input, Operand<TInt32> k,
+  public <T extends TNumber> TopK<T> topK(Operand<T> input, Operand<TInt32> k,
       TopK.Options... options) {
     return TopK.create(scope, input, k, options);
   }
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 fa1b27e62bd..b17d3c81d31 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
@@ -23,7 +23,6 @@
 import org.tensorflow.EagerSession;
 import org.tensorflow.ExecutionEnvironment;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.BooleanNdArray;
 import org.tensorflow.ndarray.ByteNdArray;
 import org.tensorflow.ndarray.DoubleNdArray;
@@ -395,7 +394,7 @@ public Abort abort(Abort.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of All
    */
-  public <T extends Tensor & TNumber> All all(Operand<TBool> input, Operand<T> axis,
+  public <T extends TNumber> All all(Operand<TBool> input, Operand<T> axis,
       All.Options... options) {
     return All.create(scope, input, axis, options);
   }
@@ -414,7 +413,7 @@ public <T extends Tensor & TNumber> All all(Operand<TBool> input, Operand<T> axi
    * @param options carries optional attributes values
    * @return a new instance of Any
    */
-  public <T extends Tensor & TNumber> Any any(Operand<TBool> input, Operand<T> axis,
+  public <T extends TNumber> Any any(Operand<TBool> input, Operand<T> axis,
       Any.Options... options) {
     return Any.create(scope, input, axis, options);
   }
@@ -537,7 +536,7 @@ public AssertThat assertThat(Operand<TBool> condition, Iterable<Operand<?>> data
    * @param options carries optional attributes values
    * @return a new instance of Assign
    */
-  public <T extends Tensor> Assign<T> assign(Operand<T> ref, Operand<T> value,
+  public <T extends TType> Assign<T> assign(Operand<T> ref, Operand<T> value,
       Assign.Options... options) {
     return Assign.create(scope, ref, value, options);
   }
@@ -554,7 +553,7 @@ public <T extends Tensor> Assign<T> assign(Operand<T> ref, Operand<T> value,
    * @param options carries optional attributes values
    * @return a new instance of AssignAdd
    */
-  public <T extends Tensor> AssignAdd<T> assignAdd(Operand<T> ref, Operand<T> value,
+  public <T extends TType> AssignAdd<T> assignAdd(Operand<T> ref, Operand<T> value,
       AssignAdd.Options... options) {
     return AssignAdd.create(scope, ref, value, options);
   }
@@ -569,7 +568,7 @@ public <T extends Tensor> AssignAdd<T> assignAdd(Operand<T> ref, Operand<T> valu
    * @param value the value by which the variable will be incremented.
    * @return a new instance of AssignAddVariableOp
    */
-  public <T extends Tensor> AssignAddVariableOp assignAddVariableOp(Operand<?> resource,
+  public <T extends TType> AssignAddVariableOp assignAddVariableOp(Operand<?> resource,
       Operand<T> value) {
     return AssignAddVariableOp.create(scope, resource, value);
   }
@@ -586,7 +585,7 @@ public <T extends Tensor> AssignAddVariableOp assignAddVariableOp(Operand<?> res
    * @param options carries optional attributes values
    * @return a new instance of AssignSub
    */
-  public <T extends Tensor> AssignSub<T> assignSub(Operand<T> ref, Operand<T> value,
+  public <T extends TType> AssignSub<T> assignSub(Operand<T> ref, Operand<T> value,
       AssignSub.Options... options) {
     return AssignSub.create(scope, ref, value, options);
   }
@@ -601,7 +600,7 @@ public <T extends Tensor> AssignSub<T> assignSub(Operand<T> ref, Operand<T> valu
    * @param value the value by which the variable will be incremented.
    * @return a new instance of AssignSubVariableOp
    */
-  public <T extends Tensor> AssignSubVariableOp assignSubVariableOp(Operand<?> resource,
+  public <T extends TType> AssignSubVariableOp assignSubVariableOp(Operand<?> resource,
       Operand<T> value) {
     return AssignSubVariableOp.create(scope, resource, value);
   }
@@ -616,7 +615,7 @@ public <T extends Tensor> AssignSubVariableOp assignSubVariableOp(Operand<?> res
    * @param value the value to set the new tensor to use.
    * @return a new instance of AssignVariableOp
    */
-  public <T extends Tensor> AssignVariableOp assignVariableOp(Operand<?> resource,
+  public <T extends TType> AssignVariableOp assignVariableOp(Operand<?> resource,
       Operand<T> value) {
     return AssignVariableOp.create(scope, resource, value);
   }
@@ -684,7 +683,7 @@ public BarrierIncompleteSize barrierIncompleteSize(Operand<TString> handle) {
    * @param componentIndex The component of the barrier elements that is being assigned.
    * @return a new instance of BarrierInsertMany
    */
-  public <T extends Tensor> BarrierInsertMany barrierInsertMany(Operand<TString> handle,
+  public <T extends TType> BarrierInsertMany barrierInsertMany(Operand<TString> handle,
       Operand<TString> keys, Operand<T> values, Long componentIndex) {
     return BarrierInsertMany.create(scope, handle, keys, values, componentIndex);
   }
@@ -799,8 +798,8 @@ public Batch batch(Iterable<Operand<?>> inTensors, Long numBatchThreads, Long ma
    * @param blockSize
    * @return a new instance of BatchToSpace
    */
-  public <T extends Tensor, U extends Tensor & TNumber> BatchToSpace<T> batchToSpace(
-      Operand<T> input, Operand<U> crops, Long blockSize) {
+  public <T extends TType, U extends TNumber> BatchToSpace<T> batchToSpace(Operand<T> input,
+      Operand<U> crops, Long blockSize) {
     return BatchToSpace.create(scope, input, crops, blockSize);
   }
 
@@ -914,7 +913,7 @@ public <T extends Tensor, U extends Tensor & TNumber> BatchToSpace<T> batchToSpa
    *  }</pre>
    * @return a new instance of BatchToSpaceNd
    */
-  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> BatchToSpaceNd<T> batchToSpaceNd(
+  public <T extends TType, U extends TNumber, V extends TNumber> BatchToSpaceNd<T> batchToSpaceNd(
       Operand<T> input, Operand<U> blockShape, Operand<V> crops) {
     return BatchToSpaceNd.create(scope, input, blockShape, crops);
   }
@@ -978,8 +977,7 @@ public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber
    * @param type
    * @return a new instance of Bitcast
    */
-  public <U extends Tensor, T extends Tensor> Bitcast<U> bitcast(Operand<T> input,
-      DataType<U> type) {
+  public <U extends TType, T extends TType> Bitcast<U> bitcast(Operand<T> input, DataType<U> type) {
     return Bitcast.create(scope, input, type);
   }
 
@@ -994,7 +992,7 @@ public <U extends Tensor, T extends Tensor> Bitcast<U> bitcast(Operand<T> input,
    * @param s1
    * @return a new instance of BroadcastDynamicShape
    */
-  public <T extends Tensor & TNumber> BroadcastDynamicShape<T> broadcastDynamicShape(Operand<T> s0,
+  public <T extends TNumber> BroadcastDynamicShape<T> broadcastDynamicShape(Operand<T> s0,
       Operand<T> s1) {
     return BroadcastDynamicShape.create(scope, s0, s1);
   }
@@ -1026,7 +1024,7 @@ public <T extends Tensor & TNumber> BroadcastDynamicShape<T> broadcastDynamicSha
    * @param shape An 1-D `int` Tensor. The shape of the desired output.
    * @return a new instance of BroadcastTo
    */
-  public <T extends Tensor, U extends Tensor & TNumber> BroadcastTo<T> broadcastTo(Operand<T> input,
+  public <T extends TType, U extends TNumber> BroadcastTo<T> broadcastTo(Operand<T> input,
       Operand<U> shape) {
     return BroadcastTo.create(scope, input, shape);
   }
@@ -1049,11 +1047,21 @@ public <T extends Tensor, U extends Tensor & TNumber> BroadcastTo<T> broadcastTo
    * @param boundaries A sorted list of floats gives the boundary of the buckets.
    * @return a new instance of Bucketize
    */
-  public <T extends Tensor & TNumber> Bucketize bucketize(Operand<T> input,
-      List<Float> boundaries) {
+  public <T extends TNumber> Bucketize bucketize(Operand<T> input, List<Float> boundaries) {
     return Bucketize.create(scope, input, boundaries);
   }
 
+  /**
+   * Create a constant from a Tensor.
+   *
+   * @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> Constant<T> capture(T tensor) {
+    return Constant.create(scope, tensor);
+  }
+
   /**
    * Clips tensor values to a specified min and max.
    *  <p>
@@ -1070,7 +1078,7 @@ public <T extends Tensor & TNumber> Bucketize bucketize(Operand<T> input,
    *  as `t`. The maximum value to clip by.
    * @return a new instance of ClipByValue
    */
-  public <T extends Tensor> ClipByValue<T> clipByValue(Operand<T> t, Operand<T> clipValueMin,
+  public <T extends TType> ClipByValue<T> clipByValue(Operand<T> t, Operand<T> clipValueMin,
       Operand<T> clipValueMax) {
     return ClipByValue.create(scope, t, clipValueMin, clipValueMax);
   }
@@ -1085,8 +1093,8 @@ public <T extends Tensor> ClipByValue<T> clipByValue(Operand<T> t, Operand<T> cl
    *  range [-rank(values), rank(values)).
    * @return a new instance of Concat
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Concat<T> concat(
-      Iterable<Operand<T>> values, Operand<U> axis) {
+  public <T extends TType, U extends TNumber> Concat<T> concat(Iterable<Operand<T>> values,
+      Operand<U> axis) {
     return Concat.create(scope, values, axis);
   }
 
@@ -1689,17 +1697,6 @@ public Constant<TInt64> constant(Shape shape) {
     return Constant.tensorOf(scope, shape);
   }
 
-  /**
-   * Create a constant from a Tensor.
-   *
-   * @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 Tensor & TType> Constant<T> constant(T tensor) {
-    return Constant.create(scope, tensor);
-  }
-
   /**
    * Creates a constant of {@code String} elements, using the given charset.
    *
@@ -1855,7 +1852,7 @@ public Constant<TString> constant(Charset charset, Shape shape, DataBuffer<Strin
    * @throws IllegalArgumentException If the tensor datatype or shape is not compatible with the
    *      buffer
    */
-  public <T extends Tensor & TType> Constant<T> constant(DataType<T> type, Shape shape,
+  public <T extends TType> Constant<T> constant(DataType<T> type, Shape shape,
       ByteDataBuffer data) {
     return Constant.tensorOf(scope, type, shape, data);
   }
@@ -1898,7 +1895,7 @@ public ControlTrigger controlTrigger() {
    *  'OutOfRange' error.
    * @return a new instance of CountUpTo
    */
-  public <T extends Tensor & TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long limit) {
+  public <T extends TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long limit) {
     return CountUpTo.create(scope, ref, limit);
   }
 
@@ -1909,7 +1906,7 @@ public <T extends Tensor & TNumber> CountUpTo<T> countUpTo(Operand<T> ref, Long
    * @param x The source tensor of type `T`.
    * @return a new instance of DeepCopy
    */
-  public <T extends Tensor> DeepCopy<T> deepCopy(Operand<T> x) {
+  public <T extends TType> DeepCopy<T> deepCopy(Operand<T> x) {
     return DeepCopy.create(scope, x);
   }
 
@@ -1955,7 +1952,7 @@ public DestroyResourceOp destroyResourceOp(Operand<?> resource,
    *  'TemporaryVariable' op.
    * @return a new instance of DestroyTemporaryVariable
    */
-  public <T extends Tensor> DestroyTemporaryVariable<T> destroyTemporaryVariable(Operand<T> ref,
+  public <T extends TType> DestroyTemporaryVariable<T> destroyTemporaryVariable(Operand<T> ref,
       String varName) {
     return DestroyTemporaryVariable.create(scope, ref, varName);
   }
@@ -2003,7 +2000,7 @@ public <T extends Tensor> DestroyTemporaryVariable<T> destroyTemporaryVariable(O
    * @param numPartitions The number of partitions to output.
    * @return a new instance of DynamicPartition
    */
-  public <T extends Tensor> DynamicPartition<T> dynamicPartition(Operand<T> data,
+  public <T extends TType> DynamicPartition<T> dynamicPartition(Operand<T> data,
       Operand<TInt32> partitions, Long numPartitions) {
     return DynamicPartition.create(scope, data, partitions, numPartitions);
   }
@@ -2071,7 +2068,7 @@ public <T extends Tensor> DynamicPartition<T> dynamicPartition(Operand<T> data,
    * @param data
    * @return a new instance of DynamicStitch
    */
-  public <T extends Tensor> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32>> indices,
+  public <T extends TType> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32>> indices,
       Iterable<Operand<T>> data) {
     return DynamicStitch.create(scope, indices, data);
   }
@@ -2100,7 +2097,7 @@ public <T extends Tensor> DynamicStitch<T> dynamicStitch(Iterable<Operand<TInt32
    * @param options carries optional attributes values
    * @return a new instance of EditDistance
    */
-  public <T extends Tensor> EditDistance editDistance(Operand<TInt64> hypothesisIndices,
+  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);
@@ -2117,7 +2114,7 @@ public <T extends Tensor> EditDistance editDistance(Operand<TInt64> hypothesisIn
    * @param options carries optional attributes values
    * @return a new instance of Empty
    */
-  public <T extends Tensor> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtype,
+  public <T extends TType> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtype,
       Empty.Options... options) {
     return Empty.create(scope, shape, dtype, options);
   }
@@ -2137,7 +2134,7 @@ public <T extends Tensor> Empty<T> empty(Operand<TInt32> shape, DataType<T> dtyp
    * @param elementDtype
    * @return a new instance of EmptyTensorList
    */
-  public <T extends Tensor & TNumber, U extends Tensor> EmptyTensorList emptyTensorList(
+  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);
   }
@@ -2153,7 +2150,7 @@ public <T extends Tensor & TNumber, U extends Tensor> EmptyTensorList emptyTenso
    * @param shape The expected (possibly partially specified) shape of the input tensor.
    * @return a new instance of EnsureShape
    */
-  public <T extends Tensor> EnsureShape<T> ensureShape(Operand<T> input, Shape shape) {
+  public <T extends TType> EnsureShape<T> ensureShape(Operand<T> input, Shape shape) {
     return EnsureShape.create(scope, input, shape);
   }
 
@@ -2196,7 +2193,7 @@ public <T extends Tensor> EnsureShape<T> ensureShape(Operand<T> input, Shape sha
    *  `[-rank(input) - 1, rank(input)]`.
    * @return a new instance of ExpandDims
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ExpandDims<T> expandDims(Operand<T> input,
+  public <T extends TType, U extends TNumber> ExpandDims<T> expandDims(Operand<T> input,
       Operand<U> axis) {
     return ExpandDims.create(scope, input, axis);
   }
@@ -2218,7 +2215,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ExpandDims<T> expandDims(O
    *  }</pre>
    * @return a new instance of ExtractVolumePatches
    */
-  public <T extends Tensor & TNumber> ExtractVolumePatches<T> extractVolumePatches(Operand<T> input,
+  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);
   }
@@ -2257,8 +2254,7 @@ public <T extends Tensor & TNumber> ExtractVolumePatches<T> extractVolumePatches
    * @end_compatibility
    * @return a new instance of Fill
    */
-  public <U extends Tensor, T extends Tensor & TNumber> Fill<U> fill(Operand<T> dims,
-      Operand<U> value) {
+  public <U extends TType, T extends TNumber> Fill<U> fill(Operand<T> dims, Operand<U> value) {
     return Fill.create(scope, dims, value);
   }
 
@@ -2299,7 +2295,7 @@ public <U extends Tensor, T extends Tensor & TNumber> Fill<U> fill(Operand<T> di
    *  `farmhash::fingerprint64`.
    * @return a new instance of Fingerprint
    */
-  public <T extends Tensor> Fingerprint fingerprint(Operand<T> data, Operand<TString> method) {
+  public <T extends TType> Fingerprint fingerprint(Operand<T> data, Operand<TString> method) {
     return Fingerprint.create(scope, data, method);
   }
 
@@ -2341,8 +2337,8 @@ public <T extends Tensor> Fingerprint fingerprint(Operand<T> data, Operand<TStri
    * @param options carries optional attributes values
    * @return a new instance of Gather
    */
-  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Gather<T> gather(
-      Operand<T> params, Operand<U> indices, Operand<V> axis, Gather.Options... options) {
+  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);
   }
 
@@ -2447,7 +2443,7 @@ public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber
    * @param indices Index tensor.
    * @return a new instance of GatherNd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> GatherNd<T> gatherNd(Operand<T> params,
+  public <T extends TType, U extends TNumber> GatherNd<T> gatherNd(Operand<T> params,
       Operand<U> indices) {
     return GatherNd.create(scope, params, indices);
   }
@@ -2458,7 +2454,7 @@ public <T extends Tensor, U extends Tensor & TNumber> GatherNd<T> gatherNd(Opera
    * @param value The tensor to be stored.
    * @return a new instance of GetSessionHandle
    */
-  public <T extends Tensor> GetSessionHandle getSessionHandle(Operand<T> value) {
+  public <T extends TType> GetSessionHandle getSessionHandle(Operand<T> value) {
     return GetSessionHandle.create(scope, value);
   }
 
@@ -2470,7 +2466,7 @@ public <T extends Tensor> GetSessionHandle getSessionHandle(Operand<T> value) {
    * @param dtype The type of the output value.
    * @return a new instance of GetSessionTensor
    */
-  public <T extends Tensor> GetSessionTensor<T> getSessionTensor(Operand<TString> handle,
+  public <T extends TType> GetSessionTensor<T> getSessionTensor(Operand<TString> handle,
       DataType<T> dtype) {
     return GetSessionTensor.create(scope, handle, dtype);
   }
@@ -2535,7 +2531,7 @@ public Gradients gradients(Operand<?> y, Iterable<? extends Operand<?>> x,
    * @param input
    * @return a new instance of GuaranteeConst
    */
-  public <T extends Tensor> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
+  public <T extends TType> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
     return GuaranteeConst.create(scope, input);
   }
 
@@ -2551,7 +2547,7 @@ public <T extends Tensor> GuaranteeConst<T> guaranteeConst(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of HashTable
    */
-  public <T extends Tensor, U extends Tensor> HashTable hashTable(DataType<T> keyDtype,
+  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);
   }
@@ -2582,8 +2578,8 @@ public <T extends Tensor, U extends Tensor> HashTable hashTable(DataType<T> keyD
    * @param nbins Scalar `int32 Tensor`.  Number of histogram bins.
    * @return a new instance of HistogramFixedWidth
    */
-  public <T extends Tensor & TNumber> HistogramFixedWidth<TInt32> histogramFixedWidth(
-      Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins) {
+  public <T extends TNumber> HistogramFixedWidth<TInt32> histogramFixedWidth(Operand<T> values,
+      Operand<T> valueRange, Operand<TInt32> nbins) {
     return HistogramFixedWidth.create(scope, values, valueRange, nbins);
   }
 
@@ -2614,7 +2610,7 @@ public <T extends Tensor & TNumber> HistogramFixedWidth<TInt32> histogramFixedWi
    * @param dtype
    * @return a new instance of HistogramFixedWidth
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> HistogramFixedWidth<U> histogramFixedWidth(
+  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);
   }
@@ -2626,7 +2622,7 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> HistogramFixedWi
    * @param input
    * @return a new instance of Identity
    */
-  public <T extends Tensor> Identity<T> identity(Operand<T> input) {
+  public <T extends TType> Identity<T> identity(Operand<T> input) {
     return Identity.create(scope, input);
   }
 
@@ -2665,7 +2661,7 @@ public IdentityN identityN(Iterable<Operand<?>> input) {
    *  NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
    * @return a new instance of ImmutableConst
    */
-  public <T extends Tensor> ImmutableConst<T> immutableConst(DataType<T> dtype, Shape shape,
+  public <T extends TType> ImmutableConst<T> immutableConst(DataType<T> dtype, Shape shape,
       String memoryRegionName) {
     return ImmutableConst.create(scope, dtype, shape, memoryRegionName);
   }
@@ -2755,8 +2751,8 @@ public void initAdd(Op initializer) {
    * @param values Values of type Tval.
    * @return a new instance of InitializeTable
    */
-  public <T extends Tensor, U extends Tensor> InitializeTable initializeTable(
-      Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+  public <T extends TType, U extends TType> InitializeTable initializeTable(Operand<?> tableHandle,
+      Operand<T> keys, Operand<U> values) {
     return InitializeTable.create(scope, tableHandle, keys, values);
   }
 
@@ -2799,8 +2795,7 @@ public InitializeTableFromTextFile initializeTableFromTextFile(Operand<?> tableH
    * @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 Tensor> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32> i,
-      Operand<T> v) {
+  public <T extends TType> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     return InplaceAdd.create(scope, x, i, v);
   }
 
@@ -2815,8 +2810,7 @@ public <T extends Tensor> InplaceAdd<T> inplaceAdd(Operand<T> x, Operand<TInt32>
    * @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 Tensor> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32> i,
-      Operand<T> v) {
+  public <T extends TType> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     return InplaceSub.create(scope, x, i, v);
   }
 
@@ -2831,7 +2825,7 @@ public <T extends Tensor> InplaceSub<T> inplaceSub(Operand<T> x, Operand<TInt32>
    * @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 Tensor> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<TInt32> i,
+  public <T extends TType> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<TInt32> i,
       Operand<T> v) {
     return InplaceUpdate.create(scope, x, i, v);
   }
@@ -2844,7 +2838,7 @@ public <T extends Tensor> InplaceUpdate<T> inplaceUpdate(Operand<T> x, Operand<T
    * @param ref Should be from a `Variable` node. May be uninitialized.
    * @return a new instance of IsVariableInitialized
    */
-  public <T extends Tensor> IsVariableInitialized isVariableInitialized(Operand<T> ref) {
+  public <T extends TType> IsVariableInitialized isVariableInitialized(Operand<T> ref) {
     return IsVariableInitialized.create(scope, ref);
   }
 
@@ -2866,8 +2860,8 @@ public <T extends Tensor> IsVariableInitialized isVariableInitialized(Operand<T>
    * @param num 0-D tensor. Number of values to generate.
    * @return a new instance of LinSpace
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> LinSpace<T> linSpace(
-      Operand<T> start, Operand<T> stop, Operand<U> num) {
+  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);
   }
 
@@ -2881,7 +2875,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> LinSpace<T> linS
    * @param Tvalues
    * @return a new instance of LookupTableExport
    */
-  public <T extends Tensor, U extends Tensor> LookupTableExport<T, U> lookupTableExport(
+  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);
   }
@@ -2901,7 +2895,7 @@ public <T extends Tensor, U extends Tensor> LookupTableExport<T, U> lookupTableE
    * @param defaultValue
    * @return a new instance of LookupTableFind
    */
-  public <U extends Tensor, T extends Tensor> LookupTableFind<U> lookupTableFind(
+  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);
   }
@@ -2917,7 +2911,7 @@ public <U extends Tensor, T extends Tensor> LookupTableFind<U> lookupTableFind(
    * @param values Values to associate with keys.
    * @return a new instance of LookupTableImport
    */
-  public <T extends Tensor, U extends Tensor> LookupTableImport lookupTableImport(
+  public <T extends TType, U extends TType> LookupTableImport lookupTableImport(
       Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     return LookupTableImport.create(scope, tableHandle, keys, values);
   }
@@ -2933,7 +2927,7 @@ public <T extends Tensor, U extends Tensor> LookupTableImport lookupTableImport(
    * @param values Values to associate with keys.
    * @return a new instance of LookupTableInsert
    */
-  public <T extends Tensor, U extends Tensor> LookupTableInsert lookupTableInsert(
+  public <T extends TType, U extends TType> LookupTableInsert lookupTableInsert(
       Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     return LookupTableInsert.create(scope, tableHandle, keys, values);
   }
@@ -3076,8 +3070,8 @@ public MapUnstageNoKey mapUnstageNoKey(Operand<TInt32> indices, List<DataType<?>
    * @param options carries optional attributes values
    * @return a new instance of Max
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Max<T> max(Operand<T> input,
-      Operand<U> axis, Max.Options... 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);
   }
 
@@ -3094,7 +3088,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Max<T> max(Operand<T> inpu
    * @param inputs The input tensors, exactly one of which will become available.
    * @return a new instance of Merge
    */
-  public <T extends Tensor> Merge<T> merge(Iterable<Operand<T>> inputs) {
+  public <T extends TType> Merge<T> merge(Iterable<Operand<T>> inputs) {
     return Merge.create(scope, inputs);
   }
 
@@ -3113,8 +3107,8 @@ public <T extends Tensor> Merge<T> merge(Iterable<Operand<T>> inputs) {
    * @param options carries optional attributes values
    * @return a new instance of Min
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Min<T> min(Operand<T> input,
-      Operand<U> axis, Min.Options... options) {
+  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);
   }
 
@@ -3157,7 +3151,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Min<T> min(Operand<T> inpu
    *  it is `[1, 2, 3, 3, 2]` in symmetric mode.
    * @return a new instance of MirrorPad
    */
-  public <T extends Tensor, U extends Tensor & TNumber> MirrorPad<T> mirrorPad(Operand<T> input,
+  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);
   }
@@ -3219,7 +3213,7 @@ public MlirPassthroughOp mlirPassthroughOp(Iterable<Operand<?>> inputs, String m
    * @param options carries optional attributes values
    * @return a new instance of MutableDenseHashTable
    */
-  public <T extends Tensor, U extends Tensor> MutableDenseHashTable mutableDenseHashTable(
+  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);
@@ -3237,8 +3231,8 @@ public <T extends Tensor, U extends Tensor> MutableDenseHashTable mutableDenseHa
    * @param options carries optional attributes values
    * @return a new instance of MutableHashTable
    */
-  public <T extends Tensor, U extends Tensor> MutableHashTable mutableHashTable(
-      DataType<T> keyDtype, DataType<U> valueDtype, MutableHashTable.Options... 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);
   }
 
@@ -3254,7 +3248,7 @@ public <T extends Tensor, U extends Tensor> MutableHashTable mutableHashTable(
    * @param options carries optional attributes values
    * @return a new instance of MutableHashTableOfTensors
    */
-  public <T extends Tensor, U extends Tensor> MutableHashTableOfTensors mutableHashTableOfTensors(
+  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);
   }
@@ -3322,7 +3316,7 @@ public MutexLock mutexLock(Operand<?> mutex) {
    * @param data The tensor to be made available to the next iteration.
    * @return a new instance of NextIteration
    */
-  public <T extends Tensor> NextIteration<T> nextIteration(Operand<T> data) {
+  public <T extends TType> NextIteration<T> nextIteration(Operand<T> data) {
     return NextIteration.create(scope, data);
   }
 
@@ -3426,7 +3420,7 @@ public NoOp noOp() {
    * @param options carries optional attributes values
    * @return a new instance of OneHot
    */
-  public <U extends Tensor, T extends Tensor & TNumber> OneHot<U> oneHot(Operand<T> indices,
+  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);
   }
@@ -3438,7 +3432,7 @@ public <U extends Tensor, T extends Tensor & TNumber> OneHot<U> oneHot(Operand<T
    * @param x a tensor of type T.
    * @return a new instance of OnesLike
    */
-  public <T extends Tensor> OnesLike<T> onesLike(Operand<T> x) {
+  public <T extends TType> OnesLike<T> onesLike(Operand<T> x) {
     return OnesLike.create(scope, x);
   }
 
@@ -3580,8 +3574,8 @@ public OrderedMapUnstageNoKey orderedMapUnstageNoKey(Operand<TInt32> indices,
    * @param constantValues
    * @return a new instance of Pad
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Pad<T> pad(Operand<T> input,
-      Operand<U> paddings, Operand<T> constantValues) {
+  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);
   }
 
@@ -3610,7 +3604,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Pad<T> pad(Operand<T> inpu
    *  but with the number of input values in the first dimension.
    * @return a new instance of ParallelConcat
    */
-  public <T extends Tensor> ParallelConcat<T> parallelConcat(Iterable<Operand<T>> values,
+  public <T extends TType> ParallelConcat<T> parallelConcat(Iterable<Operand<T>> values,
       Shape shape) {
     return ParallelConcat.create(scope, values, shape);
   }
@@ -3677,7 +3671,7 @@ public <T extends Tensor> ParallelConcat<T> parallelConcat(Iterable<Operand<T>>
    * @param data
    * @return a new instance of ParallelDynamicStitch
    */
-  public <T extends Tensor> ParallelDynamicStitch<T> parallelDynamicStitch(
+  public <T extends TType> ParallelDynamicStitch<T> parallelDynamicStitch(
       Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
     return ParallelDynamicStitch.create(scope, indices, data);
   }
@@ -3694,7 +3688,7 @@ public <T extends Tensor> ParallelDynamicStitch<T> parallelDynamicStitch(
    * @param options carries optional attributes values
    * @return a new instance of Placeholder
    */
-  public <T extends Tensor> Placeholder<T> placeholder(DataType<T> dtype,
+  public <T extends TType> Placeholder<T> placeholder(DataType<T> dtype,
       Placeholder.Options... options) {
     return Placeholder.create(scope, dtype, options);
   }
@@ -3707,7 +3701,7 @@ public <T extends Tensor> Placeholder<T> placeholder(DataType<T> dtype,
    * @param shape The (possibly partial) shape of the tensor.
    * @return a new instance of PlaceholderWithDefault
    */
-  public <T extends Tensor> PlaceholderWithDefault<T> placeholderWithDefault(Operand<T> input,
+  public <T extends TType> PlaceholderWithDefault<T> placeholderWithDefault(Operand<T> input,
       Shape shape) {
     return PlaceholderWithDefault.create(scope, input, shape);
   }
@@ -3740,8 +3734,8 @@ public Print print(Operand<TString> input, Print.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of Prod
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Prod<T> prod(Operand<T> input,
-      Operand<U> axis, Prod.Options... 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);
   }
 
@@ -3757,7 +3751,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Prod<T> prod(Operand<T> in
    * @param inputMax The maximum value of the input.
    * @return a new instance of QuantizedReshape
    */
-  public <T extends Tensor, U extends Tensor & TNumber> QuantizedReshape<T> quantizedReshape(
+  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);
   }
@@ -3782,8 +3776,7 @@ public <T extends Tensor, U extends Tensor & TNumber> QuantizedReshape<T> quanti
    * @param delta 0-D (scalar). Optional. Default is 1. Number that increments `start`.
    * @return a new instance of Range
    */
-  public <T extends Tensor & TNumber> Range<T> range(Operand<T> start, Operand<T> limit,
-      Operand<T> delta) {
+  public <T extends TNumber> Range<T> range(Operand<T> start, Operand<T> limit, Operand<T> delta) {
     return Range.create(scope, start, limit, delta);
   }
 
@@ -3805,7 +3798,7 @@ public <T extends Tensor & TNumber> Range<T> range(Operand<T> start, Operand<T>
    * @param input
    * @return a new instance of Rank
    */
-  public <T extends Tensor> Rank rank(Operand<T> input) {
+  public <T extends TType> Rank rank(Operand<T> input) {
     return Rank.create(scope, input);
   }
 
@@ -3824,7 +3817,7 @@ public <T extends Tensor> Rank rank(Operand<T> input) {
    * @param dtype the dtype of the value.
    * @return a new instance of ReadVariableOp
    */
-  public <T extends Tensor> ReadVariableOp<T> readVariableOp(Operand<?> resource,
+  public <T extends TType> ReadVariableOp<T> readVariableOp(Operand<?> resource,
       DataType<T> dtype) {
     return ReadVariableOp.create(scope, resource, dtype);
   }
@@ -3843,7 +3836,7 @@ public <T extends Tensor> ReadVariableOp<T> readVariableOp(Operand<?> resource,
    * @param options carries optional attributes values
    * @return a new instance of ReduceAll
    */
-  public <T extends Tensor & TNumber> ReduceAll reduceAll(Operand<TBool> input, Operand<T> axis,
+  public <T extends TNumber> ReduceAll reduceAll(Operand<TBool> input, Operand<T> axis,
       ReduceAll.Options... options) {
     return ReduceAll.create(scope, input, axis, options);
   }
@@ -3862,7 +3855,7 @@ public <T extends Tensor & TNumber> ReduceAll reduceAll(Operand<TBool> input, Op
    * @param options carries optional attributes values
    * @return a new instance of ReduceAny
    */
-  public <T extends Tensor & TNumber> ReduceAny reduceAny(Operand<TBool> input, Operand<T> axis,
+  public <T extends TNumber> ReduceAny reduceAny(Operand<TBool> input, Operand<T> axis,
       ReduceAny.Options... options) {
     return ReduceAny.create(scope, input, axis, options);
   }
@@ -3882,7 +3875,7 @@ public <T extends Tensor & TNumber> ReduceAny reduceAny(Operand<TBool> input, Op
    * @param options carries optional attributes values
    * @return a new instance of ReduceMax
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ReduceMax<T> reduceMax(Operand<T> input,
+  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);
   }
@@ -3902,7 +3895,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ReduceMax<T> reduceMax(Ope
    * @param options carries optional attributes values
    * @return a new instance of ReduceMin
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ReduceMin<T> reduceMin(Operand<T> input,
+  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);
   }
@@ -3922,7 +3915,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ReduceMin<T> reduceMin(Ope
    * @param options carries optional attributes values
    * @return a new instance of ReduceProd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ReduceProd<T> reduceProd(Operand<T> input,
+  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);
   }
@@ -3942,7 +3935,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ReduceProd<T> reduceProd(O
    * @param options carries optional attributes values
    * @return a new instance of ReduceSum
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ReduceSum<T> reduceSum(Operand<T> input,
+  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);
   }
@@ -3954,7 +3947,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ReduceSum<T> reduceSum(Ope
    * @param data The tensor to be made available to the next iteration.
    * @return a new instance of RefNextIteration
    */
-  public <T extends Tensor> RefNextIteration<T> refNextIteration(Operand<T> data) {
+  public <T extends TType> RefNextIteration<T> refNextIteration(Operand<T> data) {
     return RefNextIteration.create(scope, data);
   }
 
@@ -3966,7 +3959,7 @@ public <T extends Tensor> RefNextIteration<T> refNextIteration(Operand<T> data)
    * @param inputs A list of ref tensors, one of which will be forwarded to `output`.
    * @return a new instance of RefSelect
    */
-  public <T extends Tensor> RefSelect<T> refSelect(Operand<TInt32> index,
+  public <T extends TType> RefSelect<T> refSelect(Operand<TInt32> index,
       Iterable<Operand<T>> inputs) {
     return RefSelect.create(scope, index, inputs);
   }
@@ -3984,7 +3977,7 @@ public <T extends Tensor> RefSelect<T> refSelect(Operand<TInt32> index,
    * @param pred A scalar that specifies which output port will receive data.
    * @return a new instance of RefSwitch
    */
-  public <T extends Tensor> RefSwitch<T> refSwitch(Operand<T> data, Operand<TBool> pred) {
+  public <T extends TType> RefSwitch<T> refSwitch(Operand<T> data, Operand<TBool> pred) {
     return RefSwitch.create(scope, data, pred);
   }
 
@@ -4077,7 +4070,7 @@ public RemoteFusedGraphExecute remoteFusedGraphExecute(Iterable<Operand<?>> inpu
    * @param shape Defines the shape of the output tensor.
    * @return a new instance of Reshape
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Reshape<T> reshape(Operand<T> tensor,
+  public <T extends TType, U extends TNumber> Reshape<T> reshape(Operand<T> tensor,
       Operand<U> shape) {
     return Reshape.create(scope, tensor, shape);
   }
@@ -4092,8 +4085,8 @@ public <T extends Tensor, U extends Tensor & TNumber> Reshape<T> reshape(Operand
    * @param T
    * @return a new instance of ResourceCountUpTo
    */
-  public <T extends Tensor & TNumber> ResourceCountUpTo<T> resourceCountUpTo(Operand<?> resource,
-      Long limit, DataType<T> T) {
+  public <T extends TNumber> ResourceCountUpTo<T> resourceCountUpTo(Operand<?> resource, Long limit,
+      DataType<T> T) {
     return ResourceCountUpTo.create(scope, resource, limit, T);
   }
 
@@ -4120,9 +4113,8 @@ public <T extends Tensor & TNumber> ResourceCountUpTo<T> resourceCountUpTo(Opera
    * @param options carries optional attributes values
    * @return a new instance of ResourceGather
    */
-  public <U extends Tensor, T extends Tensor & TNumber> ResourceGather<U> resourceGather(
-      Operand<?> resource, Operand<T> indices, DataType<U> dtype,
-      ResourceGather.Options... 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);
   }
 
@@ -4134,7 +4126,7 @@ public <U extends Tensor, T extends Tensor & TNumber> ResourceGather<U> resource
    * @param dtype
    * @return a new instance of ResourceGatherNd
    */
-  public <U extends Tensor, T extends Tensor & TNumber> ResourceGatherNd<U> resourceGatherNd(
+  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);
   }
@@ -4167,7 +4159,7 @@ public <U extends Tensor, T extends Tensor & TNumber> ResourceGatherNd<U> resour
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterAdd
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterAdd resourceScatterAdd(
+  public <T extends TNumber, U extends TType> ResourceScatterAdd resourceScatterAdd(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterAdd.create(scope, resource, indices, updates);
   }
@@ -4200,7 +4192,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterAdd resourc
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterDiv
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterDiv resourceScatterDiv(
+  public <T extends TNumber, U extends TType> ResourceScatterDiv resourceScatterDiv(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterDiv.create(scope, resource, indices, updates);
   }
@@ -4233,7 +4225,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterDiv resourc
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterMax
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMax resourceScatterMax(
+  public <T extends TNumber, U extends TType> ResourceScatterMax resourceScatterMax(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterMax.create(scope, resource, indices, updates);
   }
@@ -4266,7 +4258,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMax resourc
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterMin
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMin resourceScatterMin(
+  public <T extends TNumber, U extends TType> ResourceScatterMin resourceScatterMin(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterMin.create(scope, resource, indices, updates);
   }
@@ -4299,7 +4291,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMin resourc
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterMul
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMul resourceScatterMul(
+  public <T extends TNumber, U extends TType> ResourceScatterMul resourceScatterMul(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterMul.create(scope, resource, indices, updates);
   }
@@ -4345,7 +4337,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMul resourc
    * @param options carries optional attributes values
    * @return a new instance of ResourceScatterNdAdd
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdAdd resourceScatterNdAdd(
+  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);
@@ -4392,7 +4384,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdAdd resou
    * @param options carries optional attributes values
    * @return a new instance of ResourceScatterNdSub
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdSub resourceScatterNdSub(
+  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);
@@ -4441,7 +4433,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdSub resou
    * @param options carries optional attributes values
    * @return a new instance of ResourceScatterNdUpdate
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdUpdate resourceScatterNdUpdate(
+  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);
@@ -4475,7 +4467,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdUpdate re
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterSub
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterSub resourceScatterSub(
+  public <T extends TNumber, U extends TType> ResourceScatterSub resourceScatterSub(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterSub.create(scope, resource, indices, updates);
   }
@@ -4499,7 +4491,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterSub resourc
    * @param updates A tensor of updated values to add to `ref`.
    * @return a new instance of ResourceScatterUpdate
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterUpdate resourceScatterUpdate(
+  public <T extends TNumber, U extends TType> ResourceScatterUpdate resourceScatterUpdate(
       Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     return ResourceScatterUpdate.create(scope, resource, indices, updates);
   }
@@ -4522,7 +4514,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceScatterUpdate reso
    * @param options carries optional attributes values
    * @return a new instance of ResourceStridedSliceAssign
    */
-  public <T extends Tensor & TNumber, U extends Tensor> ResourceStridedSliceAssign resourceStridedSliceAssign(
+  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);
@@ -4583,7 +4575,7 @@ public <T extends Tensor & TNumber, U extends Tensor> ResourceStridedSliceAssign
    *  `[-rank(tensor), rank(tensor))`.
    * @return a new instance of Reverse
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Reverse<T> reverse(Operand<T> tensor,
+  public <T extends TType, U extends TNumber> Reverse<T> reverse(Operand<T> tensor,
       Operand<U> axis) {
     return Reverse.create(scope, tensor, axis);
   }
@@ -4651,8 +4643,8 @@ public <T extends Tensor, U extends Tensor & TNumber> Reverse<T> reverse(Operand
    * @param options carries optional attributes values
    * @return a new instance of ReverseSequence
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ReverseSequence<T> reverseSequence(
-      Operand<T> input, Operand<U> seqLengths, Long seqDim, ReverseSequence.Options... options) {
+  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);
   }
 
@@ -4691,8 +4683,8 @@ public <T extends Tensor, U extends Tensor & TNumber> ReverseSequence<T> reverse
    *  axis.
    * @return a new instance of Roll
    */
-  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Roll<T> roll(
-      Operand<T> input, Operand<U> shift, Operand<V> axis) {
+  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);
   }
 
@@ -4793,7 +4785,7 @@ public Rpc rpc(Operand<TString> address, Operand<TString> method, Operand<TStrin
    * @param options carries optional attributes values
    * @return a new instance of ScatterAdd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterAdd<T> scatterAdd(Operand<T> ref,
+  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);
   }
@@ -4827,7 +4819,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterAdd<T> scatterAdd(O
    * @param options carries optional attributes values
    * @return a new instance of ScatterDiv
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterDiv<T> scatterDiv(Operand<T> ref,
+  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);
   }
@@ -4865,8 +4857,8 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterDiv<T> scatterDiv(O
    * @param options carries optional attributes values
    * @return a new instance of ScatterMax
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMax<T> scatterMax(
-      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterMax.Options... options) {
+  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);
   }
 
@@ -4903,8 +4895,8 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMax<T> sc
    * @param options carries optional attributes values
    * @return a new instance of ScatterMin
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMin<T> scatterMin(
-      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterMin.Options... options) {
+  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);
   }
 
@@ -4937,7 +4929,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMin<T> sc
    * @param options carries optional attributes values
    * @return a new instance of ScatterMul
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterMul<T> scatterMul(Operand<T> ref,
+  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);
   }
@@ -5028,7 +5020,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterMul<T> scatterMul(O
    * @param shape 1-D. The shape of the resulting tensor.
    * @return a new instance of ScatterNd
    */
-  public <U extends Tensor, T extends Tensor & TNumber> ScatterNd<U> scatterNd(Operand<T> indices,
+  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);
   }
@@ -5075,7 +5067,7 @@ public <U extends Tensor, T extends Tensor & TNumber> ScatterNd<U> scatterNd(Ope
    * @param options carries optional attributes values
    * @return a new instance of ScatterNdAdd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdAdd<T> scatterNdAdd(Operand<T> ref,
+  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);
   }
@@ -5125,7 +5117,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterNdAdd<T> scatterNdA
    *  to add to `input`.
    * @return a new instance of ScatterNdNonAliasingAdd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdNonAliasingAdd<T> scatterNdNonAliasingAdd(
+  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);
   }
@@ -5174,7 +5166,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterNdNonAliasingAdd<T>
    * @param options carries optional attributes values
    * @return a new instance of ScatterNdSub
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdSub<T> scatterNdSub(Operand<T> ref,
+  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);
   }
@@ -5225,8 +5217,8 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterNdSub<T> scatterNdS
    * @param options carries optional attributes values
    * @return a new instance of ScatterNdUpdate
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterNdUpdate<T> scatterNdUpdate(
-      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterNdUpdate.Options... 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);
   }
 
@@ -5262,7 +5254,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterNdUpdate<T> scatter
    * @param options carries optional attributes values
    * @return a new instance of ScatterSub
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterSub<T> scatterSub(Operand<T> ref,
+  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);
   }
@@ -5303,8 +5295,8 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterSub<T> scatterSub(O
    * @param options carries optional attributes values
    * @return a new instance of ScatterUpdate
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ScatterUpdate<T> scatterUpdate(
-      Operand<T> ref, Operand<U> indices, Operand<T> updates, ScatterUpdate.Options... 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);
   }
 
@@ -5316,7 +5308,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ScatterUpdate<T> scatterUp
    * @param e
    * @return a new instance of Select
    */
-  public <T extends Tensor> Select<T> select(Operand<TBool> condition, Operand<T> t, Operand<T> e) {
+  public <T extends TType> Select<T> select(Operand<TBool> condition, Operand<T> t, Operand<T> e) {
     return Select.create(scope, condition, t, e);
   }
 
@@ -5348,7 +5340,7 @@ public <T extends Tensor> Select<T> select(Operand<TBool> condition, Operand<T>
    * @param y 1-D. Values to remove.
    * @return a new instance of SetDiff1d
    */
-  public <T extends Tensor> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T> y) {
+  public <T extends TType> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T> y) {
     return SetDiff1d.create(scope, x, y);
   }
 
@@ -5381,8 +5373,8 @@ public <T extends Tensor> SetDiff1d<T, TInt32> setDiff1d(Operand<T> x, Operand<T
    * @param outIdx
    * @return a new instance of SetDiff1d
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SetDiff1d<T, U> setDiff1d(Operand<T> x,
-      Operand<T> y, DataType<U> outIdx) {
+  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);
   }
 
@@ -5402,7 +5394,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SetDiff1d<T, U> setDiff1d(
    * @param options carries optional attributes values
    * @return a new instance of SetSize
    */
-  public <T extends Tensor> SetSize setSize(Operand<TInt64> setIndices, Operand<T> setValues,
+  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);
   }
@@ -5422,7 +5414,7 @@ public <T extends Tensor> SetSize setSize(Operand<TInt64> setIndices, Operand<T>
    * @param input
    * @return a new instance of Shape
    */
-  public <T extends Tensor> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T> input) {
+  public <T extends TType> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T> input) {
     return org.tensorflow.op.core.Shape.create(scope, input);
   }
 
@@ -5442,7 +5434,7 @@ public <T extends Tensor> org.tensorflow.op.core.Shape<TInt32> shape(Operand<T>
    * @param outType
    * @return a new instance of Shape
    */
-  public <U extends Tensor & TNumber, T extends Tensor> org.tensorflow.op.core.Shape<U> 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);
   }
@@ -5456,7 +5448,7 @@ public <U extends Tensor & TNumber, T extends Tensor> org.tensorflow.op.core.Sha
    * @param input
    * @return a new instance of ShapeN
    */
-  public <T extends Tensor> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
+  public <T extends TType> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
     return ShapeN.create(scope, input);
   }
 
@@ -5470,7 +5462,7 @@ public <T extends Tensor> ShapeN<TInt32> shapeN(Iterable<Operand<T>> input) {
    * @param outType
    * @return a new instance of ShapeN
    */
-  public <U extends Tensor & TNumber, T extends Tensor> ShapeN<U> shapeN(Iterable<Operand<T>> input,
+  public <U extends TNumber, T extends TType> ShapeN<U> shapeN(Iterable<Operand<T>> input,
       DataType<U> outType) {
     return ShapeN.create(scope, input, outType);
   }
@@ -5491,7 +5483,7 @@ public <U extends Tensor & TNumber, T extends Tensor> ShapeN<U> shapeN(Iterable<
    * @param input
    * @return a new instance of Size
    */
-  public <T extends Tensor> Size<TInt32> size(Operand<T> input) {
+  public <T extends TType> Size<TInt32> size(Operand<T> input) {
     return Size.create(scope, input);
   }
 
@@ -5512,8 +5504,7 @@ public <T extends Tensor> Size<TInt32> size(Operand<T> input) {
    * @param outType
    * @return a new instance of Size
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Size<U> size(Operand<T> input,
-      DataType<U> outType) {
+  public <U extends TNumber, T extends TType> Size<U> size(Operand<T> input, DataType<U> outType) {
     return Size.create(scope, input, outType);
   }
 
@@ -5549,8 +5540,8 @@ public Skipgram skipgram(String filename, Long batchSize, Skipgram.Options... op
    *  size[i] = input.dim_size(i) - begin[i]).
    * @return a new instance of Slice
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Slice<T> slice(Operand<T> input,
-      Operand<U> begin, Operand<U> size) {
+  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);
   }
 
@@ -5561,7 +5552,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Slice<T> slice(Operand<T>
    * @param input
    * @return a new instance of Snapshot
    */
-  public <T extends Tensor> Snapshot<T> snapshot(Operand<T> input) {
+  public <T extends TType> Snapshot<T> snapshot(Operand<T> input) {
     return Snapshot.create(scope, input);
   }
 
@@ -5675,7 +5666,7 @@ public <T extends Tensor> Snapshot<T> snapshot(Operand<T> input) {
    *  regular convolution.
    * @return a new instance of SpaceToBatchNd
    */
-  public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> SpaceToBatchNd<T> 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);
   }
@@ -5691,7 +5682,7 @@ public <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber
    *  `value.shape[split_dim]`.
    * @return a new instance of Split
    */
-  public <T extends Tensor> Split<T> split(Operand<TInt32> axis, Operand<T> value, Long numSplit) {
+  public <T extends TType> Split<T> split(Operand<TInt32> axis, Operand<T> value, Long numSplit) {
     return Split.create(scope, axis, value, numSplit);
   }
 
@@ -5708,7 +5699,7 @@ public <T extends Tensor> Split<T> split(Operand<TInt32> axis, Operand<T> value,
    * @param numSplit
    * @return a new instance of SplitV
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SplitV<T> splitV(Operand<T> value,
+  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);
   }
@@ -5737,7 +5728,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SplitV<T> splitV(Operand<T
    * @param options carries optional attributes values
    * @return a new instance of Squeeze
    */
-  public <T extends Tensor> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options... options) {
+  public <T extends TType> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options... options) {
     return Squeeze.create(scope, input, options);
   }
 
@@ -5767,7 +5758,7 @@ public <T extends Tensor> Squeeze<T> squeeze(Operand<T> input, Squeeze.Options..
    * @param options carries optional attributes values
    * @return a new instance of Stack
    */
-  public <T extends Tensor> Stack<T> stack(Iterable<Operand<T>> values, Stack.Options... options) {
+  public <T extends TType> Stack<T> stack(Iterable<Operand<T>> values, Stack.Options... options) {
     return Stack.create(scope, values, options);
   }
 
@@ -5857,7 +5848,7 @@ public StageSize stageSize(List<DataType<?>> dtypes, StageSize.Options... option
    * @param input
    * @return a new instance of StopGradient
    */
-  public <T extends Tensor> StopGradient<T> stopGradient(Operand<T> input) {
+  public <T extends TType> StopGradient<T> stopGradient(Operand<T> input) {
     return StopGradient.create(scope, input);
   }
 
@@ -5968,9 +5959,8 @@ public <T extends Tensor> StopGradient<T> stopGradient(Operand<T> input) {
    * @param options carries optional attributes values
    * @return a new instance of StridedSlice
    */
-  public <T extends Tensor, U extends Tensor & TNumber> StridedSlice<T> stridedSlice(
-      Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides,
-      StridedSlice.Options... options) {
+  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);
   }
 
@@ -5993,7 +5983,7 @@ public <T extends Tensor, U extends Tensor & TNumber> StridedSlice<T> stridedSli
    * @param options carries optional attributes values
    * @return a new instance of StridedSliceAssign
    */
-  public <T extends Tensor, U extends Tensor & TNumber> StridedSliceAssign<T> stridedSliceAssign(
+  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);
@@ -6020,8 +6010,8 @@ public <T extends Tensor, U extends Tensor & TNumber> StridedSliceAssign<T> stri
    * @param options carries optional attributes values
    * @return a new instance of StridedSliceGrad
    */
-  public <U extends Tensor, T extends Tensor & TNumber> StridedSliceGrad<U> stridedSliceGrad(
-      Operand<T> shape, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> dy,
+  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);
   }
@@ -6041,8 +6031,8 @@ public <U extends Tensor, T extends Tensor & TNumber> StridedSliceGrad<U> stride
    * @param options carries optional attributes values
    * @return a new instance of Sum
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Sum<T> sum(Operand<T> input,
-      Operand<U> axis, Sum.Options... options) {
+  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);
   }
 
@@ -6059,7 +6049,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Sum<T> sum(Operand<T> inpu
    * @param pred A scalar that specifies which output port will receive data.
    * @return a new instance of SwitchCond
    */
-  public <T extends Tensor> SwitchCond<T> switchCond(Operand<T> data, Operand<TBool> pred) {
+  public <T extends TType> SwitchCond<T> switchCond(Operand<T> data, Operand<TBool> pred) {
     return SwitchCond.create(scope, data, pred);
   }
 
@@ -6087,7 +6077,7 @@ public <T extends Tensor> SwitchCond<T> switchCond(Operand<T> data, Operand<TBoo
    * @param options carries optional attributes values
    * @return a new instance of TemporaryVariable
    */
-  public <T extends Tensor> TemporaryVariable<T> temporaryVariable(Shape shape, DataType<T> dtype,
+  public <T extends TType> TemporaryVariable<T> temporaryVariable(Shape shape, DataType<T> dtype,
       TemporaryVariable.Options... options) {
     return TemporaryVariable.create(scope, shape, dtype, options);
   }
@@ -6102,7 +6092,7 @@ public <T extends Tensor> TemporaryVariable<T> temporaryVariable(Shape shape, Da
    * @param options carries optional attributes values
    * @return a new instance of TensorArray
    */
-  public <T extends Tensor> TensorArray tensorArray(Operand<TInt32> size, DataType<T> dtype,
+  public <T extends TType> TensorArray tensorArray(Operand<TInt32> size, DataType<T> dtype,
       TensorArray.Options... options) {
     return TensorArray.create(scope, size, dtype, options);
   }
@@ -6141,7 +6131,7 @@ public TensorArrayClose tensorArrayClose(Operand<?> handle) {
    * @param options carries optional attributes values
    * @return a new instance of TensorArrayConcat
    */
-  public <T extends Tensor> TensorArrayConcat<T> tensorArrayConcat(Operand<?> handle,
+  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);
   }
@@ -6159,7 +6149,7 @@ public <T extends Tensor> TensorArrayConcat<T> tensorArrayConcat(Operand<?> hand
    * @param options carries optional attributes values
    * @return a new instance of TensorArrayGather
    */
-  public <T extends Tensor> TensorArrayGather<T> tensorArrayGather(Operand<?> handle,
+  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);
@@ -6247,7 +6237,7 @@ public TensorArrayGradWithShape tensorArrayGradWithShape(Operand<?> handle,
    * @param options carries optional attributes values
    * @return a new instance of TensorArrayPack
    */
-  public <T extends Tensor> TensorArrayPack<T> tensorArrayPack(Operand<TString> handle,
+  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);
   }
@@ -6262,7 +6252,7 @@ public <T extends Tensor> TensorArrayPack<T> tensorArrayPack(Operand<TString> ha
    * @param dtype The type of the elem that is returned.
    * @return a new instance of TensorArrayRead
    */
-  public <T extends Tensor> TensorArrayRead<T> tensorArrayRead(Operand<?> handle,
+  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);
   }
@@ -6278,7 +6268,7 @@ public <T extends Tensor> TensorArrayRead<T> tensorArrayRead(Operand<?> handle,
    * @param flowIn A float scalar that enforces proper chaining of operations.
    * @return a new instance of TensorArrayScatter
    */
-  public <T extends Tensor> TensorArrayScatter tensorArrayScatter(Operand<?> handle,
+  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);
   }
@@ -6325,7 +6315,7 @@ public TensorArraySize tensorArraySize(Operand<?> handle, Operand<TFloat32> flow
    * @param flowIn A float scalar that enforces proper chaining of operations.
    * @return a new instance of TensorArraySplit
    */
-  public <T extends Tensor> TensorArraySplit tensorArraySplit(Operand<?> handle, Operand<T> value,
+  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);
   }
@@ -6337,7 +6327,7 @@ public <T extends Tensor> TensorArraySplit tensorArraySplit(Operand<?> handle, O
    * @param flowIn
    * @return a new instance of TensorArrayUnpack
    */
-  public <T extends Tensor> TensorArrayUnpack tensorArrayUnpack(Operand<TString> handle,
+  public <T extends TType> TensorArrayUnpack tensorArrayUnpack(Operand<TString> handle,
       Operand<T> value, Operand<TFloat32> flowIn) {
     return TensorArrayUnpack.create(scope, handle, value, flowIn);
   }
@@ -6351,7 +6341,7 @@ public <T extends Tensor> TensorArrayUnpack tensorArrayUnpack(Operand<TString> h
    * @param flowIn A float scalar that enforces proper chaining of operations.
    * @return a new instance of TensorArrayWrite
    */
-  public <T extends Tensor> TensorArrayWrite tensorArrayWrite(Operand<?> handle,
+  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);
   }
@@ -6378,7 +6368,7 @@ public <T extends Tensor> TensorArrayWrite tensorArrayWrite(Operand<?> handle,
    * @param elementDtype
    * @return a new instance of TensorListConcat
    */
-  public <U extends Tensor, T extends Tensor & TNumber> TensorListConcat<U> tensorListConcat(
+  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);
@@ -6391,7 +6381,7 @@ public <U extends Tensor, T extends Tensor & TNumber> TensorListConcat<U> tensor
    * @param elementDtype
    * @return a new instance of TensorListConcatLists
    */
-  public <T extends Tensor> TensorListConcatLists tensorListConcatLists(Operand<?> inputA,
+  public <T extends TType> TensorListConcatLists tensorListConcatLists(Operand<?> inputA,
       Operand<?> inputB, DataType<T> elementDtype) {
     return TensorListConcatLists.create(scope, inputA, inputB, elementDtype);
   }
@@ -6407,7 +6397,7 @@ public <T extends Tensor> TensorListConcatLists tensorListConcatLists(Operand<?>
    * @param shapeType
    * @return a new instance of TensorListElementShape
    */
-  public <T extends Tensor & TNumber> TensorListElementShape<T> tensorListElementShape(
+  public <T extends TNumber> TensorListElementShape<T> tensorListElementShape(
       Operand<?> inputHandle, DataType<T> shapeType) {
     return TensorListElementShape.create(scope, inputHandle, shapeType);
   }
@@ -6424,7 +6414,7 @@ public <T extends Tensor & TNumber> TensorListElementShape<T> tensorListElementS
    * @param elementShape
    * @return a new instance of TensorListFromTensor
    */
-  public <T extends Tensor, U extends Tensor & TNumber> TensorListFromTensor tensorListFromTensor(
+  public <T extends TType, U extends TNumber> TensorListFromTensor tensorListFromTensor(
       Operand<T> tensor, Operand<U> elementShape) {
     return TensorListFromTensor.create(scope, tensor, elementShape);
   }
@@ -6446,7 +6436,7 @@ public <T extends Tensor, U extends Tensor & TNumber> TensorListFromTensor tenso
    * @param elementDtype
    * @return a new instance of TensorListGather
    */
-  public <T extends Tensor> TensorListGather<T> tensorListGather(Operand<?> inputHandle,
+  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);
   }
@@ -6460,7 +6450,7 @@ public <T extends Tensor> TensorListGather<T> tensorListGather(Operand<?> inputH
    * @param elementDtype
    * @return a new instance of TensorListGetItem
    */
-  public <T extends Tensor> TensorListGetItem<T> tensorListGetItem(Operand<?> inputHandle,
+  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);
   }
@@ -6494,7 +6484,7 @@ public TensorListLength tensorListLength(Operand<?> inputHandle) {
    * @param elementDtype
    * @return a new instance of TensorListPopBack
    */
-  public <T extends Tensor> TensorListPopBack<T> tensorListPopBack(Operand<?> inputHandle,
+  public <T extends TType> TensorListPopBack<T> tensorListPopBack(Operand<?> inputHandle,
       Operand<TInt32> elementShape, DataType<T> elementDtype) {
     return TensorListPopBack.create(scope, inputHandle, elementShape, elementDtype);
   }
@@ -6512,7 +6502,7 @@ public <T extends Tensor> TensorListPopBack<T> tensorListPopBack(Operand<?> inpu
    * @param tensor
    * @return a new instance of TensorListPushBack
    */
-  public <T extends Tensor> TensorListPushBack tensorListPushBack(Operand<?> inputHandle,
+  public <T extends TType> TensorListPushBack tensorListPushBack(Operand<?> inputHandle,
       Operand<T> tensor) {
     return TensorListPushBack.create(scope, inputHandle, tensor);
   }
@@ -6523,7 +6513,7 @@ public <T extends Tensor> TensorListPushBack tensorListPushBack(Operand<?> input
    * @param tensor
    * @return a new instance of TensorListPushBackBatch
    */
-  public <T extends Tensor> TensorListPushBackBatch tensorListPushBackBatch(Operand<?> inputHandles,
+  public <T extends TType> TensorListPushBackBatch tensorListPushBackBatch(Operand<?> inputHandles,
       Operand<T> tensor) {
     return TensorListPushBackBatch.create(scope, inputHandles, tensor);
   }
@@ -6541,7 +6531,7 @@ public <T extends Tensor> TensorListPushBackBatch tensorListPushBackBatch(Operan
    * @param elementDtype
    * @return a new instance of TensorListReserve
    */
-  public <T extends Tensor & TNumber, U extends Tensor> TensorListReserve 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);
   }
@@ -6582,9 +6572,8 @@ public TensorListResize tensorListResize(Operand<?> inputHandle, Operand<TInt32>
    * @param numElements
    * @return a new instance of TensorListScatter
    */
-  public <T extends Tensor, U extends Tensor & TNumber> TensorListScatter tensorListScatter(
-      Operand<T> tensor, Operand<TInt32> indices, Operand<U> elementShape,
-      Operand<TInt32> numElements) {
+  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);
   }
 
@@ -6604,7 +6593,7 @@ public <T extends Tensor, U extends Tensor & TNumber> TensorListScatter tensorLi
    * @param indices
    * @return a new instance of TensorListScatterIntoExistingList
    */
-  public <T extends Tensor> TensorListScatterIntoExistingList tensorListScatterIntoExistingList(
+  public <T extends TType> TensorListScatterIntoExistingList tensorListScatterIntoExistingList(
       Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
     return TensorListScatterIntoExistingList.create(scope, inputHandle, tensor, indices);
   }
@@ -6616,7 +6605,7 @@ public <T extends Tensor> TensorListScatterIntoExistingList tensorListScatterInt
    * @param item
    * @return a new instance of TensorListSetItem
    */
-  public <T extends Tensor> TensorListSetItem tensorListSetItem(Operand<?> inputHandle,
+  public <T extends TType> TensorListSetItem tensorListSetItem(Operand<?> inputHandle,
       Operand<TInt32> index, Operand<T> item) {
     return TensorListSetItem.create(scope, inputHandle, index, item);
   }
@@ -6637,8 +6626,8 @@ public <T extends Tensor> TensorListSetItem tensorListSetItem(Operand<?> inputHa
    * @param lengths
    * @return a new instance of TensorListSplit
    */
-  public <T extends Tensor, U extends Tensor & TNumber> TensorListSplit tensorListSplit(
-      Operand<T> tensor, Operand<U> elementShape, Operand<TInt64> lengths) {
+  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);
   }
 
@@ -6658,7 +6647,7 @@ public <T extends Tensor, U extends Tensor & TNumber> TensorListSplit tensorList
    * @param options carries optional attributes values
    * @return a new instance of TensorListStack
    */
-  public <T extends Tensor> TensorListStack<T> tensorListStack(Operand<?> inputHandle,
+  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);
   }
@@ -6731,7 +6720,7 @@ public <T extends Tensor> TensorListStack<T> tensorListStack(Operand<?> inputHan
    * @param updates Updates to scatter into output.
    * @return a new instance of TensorScatterNdAdd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdAdd<T> 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);
   }
@@ -6804,7 +6793,7 @@ public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdAdd<T> tens
    * @param updates Updates to scatter into output.
    * @return a new instance of TensorScatterNdSub
    */
-  public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdSub<T> 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);
   }
@@ -6892,7 +6881,7 @@ public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdSub<T> tens
    * @param updates Updates to scatter into output.
    * @return a new instance of TensorScatterNdUpdate
    */
-  public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdUpdate<T> 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);
   }
@@ -6916,7 +6905,7 @@ public <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdUpdate<T> t
    * @param options carries optional attributes values
    * @return a new instance of TensorStridedSliceUpdate
    */
-  public <T extends Tensor, U extends Tensor & TNumber> TensorStridedSliceUpdate<T> 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);
@@ -6957,8 +6946,7 @@ public <T extends Tensor, U extends Tensor & TNumber> TensorStridedSliceUpdate<T
    * @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 Tensor, U extends Tensor & TNumber> Tile<T> tile(Operand<T> input,
-      Operand<U> multiples) {
+  public <T extends TType, U extends TNumber> Tile<T> tile(Operand<T> input, Operand<U> multiples) {
     return Tile.create(scope, input, multiples);
   }
 
@@ -7072,7 +7060,7 @@ public TryRpc tryRpc(Operand<TString> address, Operand<TString> method, Operand<
    * @param options carries optional attributes values
    * @return a new instance of Unbatch
    */
-  public <T extends Tensor> Unbatch<T> unbatch(Operand<T> batchedTensor, Operand<TInt64> batchIndex,
+  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);
   }
@@ -7103,7 +7091,7 @@ public <T extends Tensor> Unbatch<T> unbatch(Operand<T> batchedTensor, Operand<T
    * @param options carries optional attributes values
    * @return a new instance of UnbatchGrad
    */
-  public <T extends Tensor> UnbatchGrad<T> unbatchGrad(Operand<T> originalInput,
+  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);
@@ -7158,7 +7146,7 @@ public <T extends Tensor> UnbatchGrad<T> unbatchGrad(Operand<T> originalInput,
    *  find the unique elements.
    * @return a new instance of Unique
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Unique<T, TInt32> unique(Operand<T> x,
+  public <T extends TType, U extends TNumber> Unique<T, TInt32> unique(Operand<T> x,
       Operand<U> axis) {
     return Unique.create(scope, x, axis);
   }
@@ -7213,8 +7201,8 @@ public <T extends Tensor, U extends Tensor & TNumber> Unique<T, TInt32> unique(O
    * @param outIdx
    * @return a new instance of Unique
    */
-  public <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> Unique<T, V> unique(
-      Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
+  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);
   }
 
@@ -7271,7 +7259,7 @@ public <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber
    *  find the unique elements.
    * @return a new instance of UniqueWithCounts
    */
-  public <T extends Tensor, U extends Tensor & TNumber> UniqueWithCounts<T, TInt32> uniqueWithCounts(
+  public <T extends TType, U extends TNumber> UniqueWithCounts<T, TInt32> uniqueWithCounts(
       Operand<T> x, Operand<U> axis) {
     return UniqueWithCounts.create(scope, x, axis);
   }
@@ -7330,7 +7318,7 @@ public <T extends Tensor, U extends Tensor & TNumber> UniqueWithCounts<T, TInt32
    * @param outIdx
    * @return a new instance of UniqueWithCounts
    */
-  public <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> UniqueWithCounts<T, V> uniqueWithCounts(
+  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);
   }
@@ -7363,8 +7351,7 @@ public <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber
    *  indices.
    * @return a new instance of UnravelIndex
    */
-  public <T extends Tensor & TNumber> UnravelIndex<T> unravelIndex(Operand<T> indices,
-      Operand<T> dims) {
+  public <T extends TNumber> UnravelIndex<T> unravelIndex(Operand<T> indices, Operand<T> dims) {
     return UnravelIndex.create(scope, indices, dims);
   }
 
@@ -7390,7 +7377,7 @@ public <T extends Tensor & TNumber> UnravelIndex<T> unravelIndex(Operand<T> indi
    * @param options carries optional attributes values
    * @return a new instance of Unstack
    */
-  public <T extends Tensor> Unstack<T> unstack(Operand<T> value, Long num,
+  public <T extends TType> Unstack<T> unstack(Operand<T> value, Long num,
       Unstack.Options... options) {
     return Unstack.create(scope, value, num, options);
   }
@@ -7418,7 +7405,7 @@ public Unstage unstage(List<DataType<?>> dtypes, Unstage.Options... options) {
    * @param options carries optional attributes values
    * @return a new instance of VarHandleOp
    */
-  public <T extends Tensor> VarHandleOp varHandleOp(DataType<T> dtype, Shape shape,
+  public <T extends TType> VarHandleOp varHandleOp(DataType<T> dtype, Shape shape,
       VarHandleOp.Options... options) {
     return VarHandleOp.create(scope, dtype, shape, options);
   }
@@ -7444,7 +7431,7 @@ public VarIsInitializedOp varIsInitializedOp(Operand<?> resource) {
    * @param options carries optional attributes values
    * @return a new instance of Variable
    */
-  public <T extends Tensor> Variable<T> variable(Operand<T> init, Variable.Options... options) {
+  public <T extends TType> Variable<T> variable(Operand<T> init, Variable.Options... options) {
     return Helpers.createVariableWithInit(scope, init, options);
   }
 
@@ -7461,7 +7448,7 @@ public <T extends Tensor> Variable<T> variable(Operand<T> init, Variable.Options
    * @param options carries optional attributes values
    * @return a new instance of Variable
    */
-  public <T extends Tensor> Variable<T> variable(Shape shape, DataType<T> dtype,
+  public <T extends TType> Variable<T> variable(Shape shape, DataType<T> dtype,
       Variable.Options... options) {
     return Variable.create(scope, shape, dtype, options);
   }
@@ -7501,8 +7488,7 @@ public VariableShape<TInt32> variableShape(Operand<?> input) {
    * @param outType
    * @return a new instance of VariableShape
    */
-  public <T extends Tensor & TNumber> VariableShape<T> variableShape(Operand<?> input,
-      DataType<T> outType) {
+  public <T extends TNumber> VariableShape<T> variableShape(Operand<?> input, DataType<T> outType) {
     return VariableShape.create(scope, input, outType);
   }
 
@@ -7571,7 +7557,7 @@ public <T extends Tensor & TNumber> VariableShape<T> variableShape(Operand<?> in
    * @param condition
    * @return a new instance of Where
    */
-  public <T extends Tensor> Where where(Operand<T> condition) {
+  public <T extends TType> Where where(Operand<T> condition) {
     return Where.create(scope, condition);
   }
 
@@ -7584,8 +7570,7 @@ public <T extends Tensor> Where where(Operand<T> condition) {
    * @return a constant tensor initialized with zeros
    * @throws IllegalArgumentException if the tensor type or shape cannot be initialized with zeros.
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Zeros<T> zeros(Operand<U> dims,
-      DataType<T> type) {
+  public <T extends TType, U extends TNumber> Zeros<T> zeros(Operand<U> dims, DataType<T> type) {
     return Zeros.create(scope, dims, type);
   }
 
@@ -7596,7 +7581,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Zeros<T> zeros(Operand<U>
    * @param x a tensor of type T.
    * @return a new instance of ZerosLike
    */
-  public <T extends Tensor> ZerosLike<T> zerosLike(Operand<T> x) {
+  public <T extends TType> ZerosLike<T> zerosLike(Operand<T> x) {
     return ZerosLike.create(scope, x);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java
index 7f5dc4e8271..7a78cd2f011 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/QuantizationOps.java
@@ -19,7 +19,6 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.quantization.Dequantize;
 import org.tensorflow.op.quantization.FakeQuantWithMinMaxArgs;
 import org.tensorflow.op.quantization.FakeQuantWithMinMaxArgsGradient;
@@ -36,6 +35,7 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code quantization} operations as {@link Op Op}s
@@ -107,7 +107,7 @@ public final class QuantizationOps {
    * @param options carries optional attributes values
    * @return a new instance of Dequantize
    */
-  public <T extends Tensor> Dequantize<TFloat32> dequantize(Operand<T> input,
+  public <T extends TType> Dequantize<TFloat32> dequantize(Operand<T> input,
       Operand<TFloat32> minRange, Operand<TFloat32> maxRange, Dequantize.Options... options) {
     return Dequantize.create(scope, input, minRange, maxRange, options);
   }
@@ -172,7 +172,7 @@ public <T extends Tensor> Dequantize<TFloat32> dequantize(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of Dequantize
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Dequantize<U> dequantize(Operand<T> input,
+  public <U extends TNumber, T extends TType> Dequantize<U> dequantize(Operand<T> input,
       Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<U> dtype,
       Dequantize.Options... options) {
     return Dequantize.create(scope, input, minRange, maxRange, dtype, options);
@@ -453,9 +453,8 @@ public FakeQuantWithMinMaxVarsPerChannelGradient fakeQuantWithMinMaxVarsPerChann
    * @param options carries optional attributes values
    * @return a new instance of Quantize
    */
-  public <T extends Tensor> Quantize<T> quantize(Operand<TFloat32> input,
-      Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<T> T,
-      Quantize.Options... options) {
+  public <T extends TType> Quantize<T> quantize(Operand<TFloat32> input, Operand<TFloat32> minRange,
+      Operand<TFloat32> maxRange, DataType<T> T, Quantize.Options... options) {
     return Quantize.create(scope, input, minRange, maxRange, T, options);
   }
 
@@ -473,8 +472,8 @@ public <T extends Tensor> Quantize<T> quantize(Operand<TFloat32> input,
    * @param options carries optional attributes values
    * @return a new instance of QuantizeAndDequantize
    */
-  public <T extends Tensor & TNumber> QuantizeAndDequantize<T> quantizeAndDequantize(
-      Operand<T> input, Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits,
+  public <T extends TNumber> QuantizeAndDequantize<T> quantizeAndDequantize(Operand<T> input,
+      Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits,
       QuantizeAndDequantize.Options... options) {
     return QuantizeAndDequantize.create(scope, input, inputMin, inputMax, numBits, options);
   }
@@ -512,7 +511,7 @@ public <T extends Tensor & TNumber> QuantizeAndDequantize<T> quantizeAndDequanti
    * @param outType The type of the output. Should be a lower bit depth than Tinput.
    * @return a new instance of QuantizeDownAndShrinkRange
    */
-  public <U extends Tensor, T extends Tensor> QuantizeDownAndShrinkRange<U> quantizeDownAndShrinkRange(
+  public <U extends TType, T extends TType> QuantizeDownAndShrinkRange<U> quantizeDownAndShrinkRange(
       Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax,
       DataType<U> outType) {
     return QuantizeDownAndShrinkRange.create(scope, input, inputMin, inputMax, outType);
@@ -530,7 +529,7 @@ public <U extends Tensor, T extends Tensor> QuantizeDownAndShrinkRange<U> quanti
    * @param inputMaxes The maximum scalar values for each of the input tensors.
    * @return a new instance of QuantizedConcat
    */
-  public <T extends Tensor> QuantizedConcat<T> quantizedConcat(Operand<TInt32> concatDim,
+  public <T extends TType> QuantizedConcat<T> quantizedConcat(Operand<TInt32> concatDim,
       Iterable<Operand<T>> values, Iterable<Operand<TFloat32>> inputMins,
       Iterable<Operand<TFloat32>> inputMaxes) {
     return QuantizedConcat.create(scope, concatDim, values, inputMins, inputMaxes);
@@ -549,7 +548,7 @@ public <T extends Tensor> QuantizedConcat<T> quantizedConcat(Operand<TInt32> con
    * @param inputMax The float value that the maximum quantized input value represents.
    * @return a new instance of RequantizationRange
    */
-  public <T extends Tensor> RequantizationRange requantizationRange(Operand<T> input,
+  public <T extends TType> RequantizationRange requantizationRange(Operand<T> input,
       Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
     return RequantizationRange.create(scope, input, inputMin, inputMax);
   }
@@ -574,7 +573,7 @@ public <T extends Tensor> RequantizationRange requantizationRange(Operand<T> inp
    * @param outType The type of the output. Should be a lower bit depth than Tinput.
    * @return a new instance of Requantize
    */
-  public <U extends Tensor, T extends Tensor> Requantize<U> requantize(Operand<T> input,
+  public <U extends TType, T extends TType> Requantize<U> requantize(Operand<T> input,
       Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin,
       Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
     return Requantize.create(scope, input, inputMin, inputMax, requestedOutputMin, requestedOutputMax, outType);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java
index cb9410ebb2a..071e77c7a70 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/RandomOps.java
@@ -19,7 +19,6 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.random.AllCandidateSampler;
 import org.tensorflow.op.random.LogUniformCandidateSampler;
 import org.tensorflow.op.random.Multinomial;
@@ -43,6 +42,7 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code random} operations as {@link Op Op}s
@@ -124,7 +124,7 @@ public LogUniformCandidateSampler logUniformCandidateSampler(Operand<TInt64> tru
    * @param options carries optional attributes values
    * @return a new instance of Multinomial
    */
-  public <T extends Tensor & TNumber> Multinomial<TInt64> multinomial(Operand<T> logits,
+  public <T extends TNumber> Multinomial<TInt64> multinomial(Operand<T> logits,
       Operand<TInt32> numSamples, Multinomial.Options... options) {
     return Multinomial.create(scope, logits, numSamples, options);
   }
@@ -140,9 +140,8 @@ public <T extends Tensor & TNumber> Multinomial<TInt64> multinomial(Operand<T> l
    * @param options carries optional attributes values
    * @return a new instance of Multinomial
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> Multinomial<U> multinomial(
-      Operand<T> logits, Operand<TInt32> numSamples, DataType<U> outputDtype,
-      Multinomial.Options... options) {
+  public <U extends TNumber, T extends TNumber> Multinomial<U> multinomial(Operand<T> logits,
+      Operand<TInt32> numSamples, DataType<U> outputDtype, Multinomial.Options... options) {
     return Multinomial.create(scope, logits, numSamples, outputDtype, options);
   }
 
@@ -162,7 +161,7 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> Multinomial<U> m
    * @param options carries optional attributes values
    * @return a new instance of ParameterizedTruncatedNormal
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> ParameterizedTruncatedNormal<U> parameterizedTruncatedNormal(
+  public <U extends TNumber, T extends TNumber> ParameterizedTruncatedNormal<U> parameterizedTruncatedNormal(
       Operand<T> shape, Operand<U> means, Operand<U> stdevs, Operand<U> minvals, Operand<U> maxvals,
       ParameterizedTruncatedNormal.Options... options) {
     return ParameterizedTruncatedNormal.create(scope, shape, means, stdevs, minvals, maxvals, options);
@@ -183,8 +182,8 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> ParameterizedTru
    * @param options carries optional attributes values
    * @return a new instance of RandomGamma
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomGamma<U> randomGamma(
-      Operand<T> shape, Operand<U> alpha, RandomGamma.Options... options) {
+  public <U extends TNumber, T extends TNumber> RandomGamma<U> randomGamma(Operand<T> shape,
+      Operand<U> alpha, RandomGamma.Options... options) {
     return RandomGamma.create(scope, shape, alpha, options);
   }
 
@@ -209,7 +208,7 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomGamma<U> r
    * @param options carries optional attributes values
    * @return a new instance of RandomPoisson
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<TInt64> randomPoisson(
+  public <T extends TNumber, U extends TNumber> RandomPoisson<TInt64> randomPoisson(
       Operand<T> shape, Operand<U> rate, RandomPoisson.Options... options) {
     return RandomPoisson.create(scope, shape, rate, options);
   }
@@ -236,7 +235,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<TI
    * @param options carries optional attributes values
    * @return a new instance of RandomPoisson
    */
-  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<V> randomPoisson(
+  public <V extends TNumber, T extends TNumber, U extends TNumber> RandomPoisson<V> randomPoisson(
       Operand<T> shape, Operand<U> rate, DataType<V> dtype, RandomPoisson.Options... options) {
     return RandomPoisson.create(scope, shape, rate, dtype, options);
   }
@@ -258,7 +257,7 @@ public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor
    * @param options carries optional attributes values
    * @return a new instance of RandomShuffle
    */
-  public <T extends Tensor> RandomShuffle<T> randomShuffle(Operand<T> value,
+  public <T extends TType> RandomShuffle<T> randomShuffle(Operand<T> value,
       RandomShuffle.Options... options) {
     return RandomShuffle.create(scope, value, options);
   }
@@ -274,7 +273,7 @@ public <T extends Tensor> RandomShuffle<T> randomShuffle(Operand<T> value,
    * @param options carries optional attributes values
    * @return a new instance of RandomStandardNormal
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomStandardNormal<U> randomStandardNormal(
+  public <U extends TNumber, T extends TNumber> RandomStandardNormal<U> randomStandardNormal(
       Operand<T> shape, DataType<U> dtype, RandomStandardNormal.Options... options) {
     return RandomStandardNormal.create(scope, shape, dtype, options);
   }
@@ -291,8 +290,8 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomStandardNo
    * @param options carries optional attributes values
    * @return a new instance of RandomUniform
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniform<U> randomUniform(
-      Operand<T> shape, DataType<U> dtype, RandomUniform.Options... options) {
+  public <U extends TNumber, T extends TNumber> RandomUniform<U> randomUniform(Operand<T> shape,
+      DataType<U> dtype, RandomUniform.Options... options) {
     return RandomUniform.create(scope, shape, dtype, options);
   }
 
@@ -314,7 +313,7 @@ public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniform<U>
    * @param options carries optional attributes values
    * @return a new instance of RandomUniformInt
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniformInt<U> randomUniformInt(
+  public <U extends TNumber, T extends TNumber> RandomUniformInt<U> randomUniformInt(
       Operand<T> shape, Operand<U> minval, Operand<U> maxval, RandomUniformInt.Options... options) {
     return RandomUniformInt.create(scope, shape, minval, maxval, options);
   }
@@ -340,7 +339,7 @@ public RecordInput recordInput(String filePattern, RecordInput.Options... option
    * @param probs
    * @return a new instance of StatefulRandomBinomial
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<TInt64> statefulRandomBinomial(
+  public <T extends TNumber, U extends TNumber> StatefulRandomBinomial<TInt64> statefulRandomBinomial(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts,
       Operand<U> probs) {
     return StatefulRandomBinomial.create(scope, resource, algorithm, shape, counts, probs);
@@ -357,7 +356,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBi
    * @param dtype
    * @return a new instance of StatefulRandomBinomial
    */
-  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<V> statefulRandomBinomial(
+  public <V extends TNumber, T extends TNumber, U extends TNumber> StatefulRandomBinomial<V> statefulRandomBinomial(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts,
       Operand<U> probs, DataType<V> dtype) {
     return StatefulRandomBinomial.create(scope, resource, algorithm, shape, counts, probs, dtype);
@@ -374,7 +373,7 @@ public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor
    * @param shape The shape of the output tensor.
    * @return a new instance of StatefulStandardNormal
    */
-  public <T extends Tensor> StatefulStandardNormal<TFloat32> statefulStandardNormal(
+  public <T extends TType> StatefulStandardNormal<TFloat32> statefulStandardNormal(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return StatefulStandardNormal.create(scope, resource, algorithm, shape);
   }
@@ -391,7 +390,7 @@ public <T extends Tensor> StatefulStandardNormal<TFloat32> statefulStandardNorma
    * @param dtype The type of the output.
    * @return a new instance of StatefulStandardNormal
    */
-  public <U extends Tensor, T extends Tensor> StatefulStandardNormal<U> statefulStandardNormal(
+  public <U extends TType, T extends TType> StatefulStandardNormal<U> statefulStandardNormal(
       Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     return StatefulStandardNormal.create(scope, resource, algorithm, shape, dtype);
   }
@@ -406,7 +405,7 @@ public <U extends Tensor, T extends Tensor> StatefulStandardNormal<U> statefulSt
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessMultinomial
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<TInt64> statelessMultinomial(
+  public <T extends TNumber, U extends TNumber> StatelessMultinomial<TInt64> statelessMultinomial(
       Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed) {
     return StatelessMultinomial.create(scope, logits, numSamples, seed);
   }
@@ -422,7 +421,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultino
    * @param outputDtype
    * @return a new instance of StatelessMultinomial
    */
-  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<V> statelessMultinomial(
+  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessMultinomial<V> statelessMultinomial(
       Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed, DataType<V> outputDtype) {
     return StatelessMultinomial.create(scope, logits, numSamples, seed, outputDtype);
   }
@@ -439,7 +438,7 @@ public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessRandomNormal
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<TFloat32> statelessRandomNormal(
+  public <T extends TNumber, U extends TNumber> StatelessRandomNormal<TFloat32> statelessRandomNormal(
       Operand<T> shape, Operand<U> seed) {
     return StatelessRandomNormal.create(scope, shape, seed);
   }
@@ -457,7 +456,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomN
    * @param dtype The type of the output.
    * @return a new instance of StatelessRandomNormal
    */
-  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<V> statelessRandomNormal(
+  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomNormal<V> statelessRandomNormal(
       Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     return StatelessRandomNormal.create(scope, shape, seed, dtype);
   }
@@ -475,7 +474,7 @@ public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessRandomUniform
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<TFloat32> statelessRandomUniform(
+  public <T extends TNumber, U extends TNumber> StatelessRandomUniform<TFloat32> statelessRandomUniform(
       Operand<T> shape, Operand<U> seed) {
     return StatelessRandomUniform.create(scope, shape, seed);
   }
@@ -494,7 +493,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomU
    * @param dtype The type of the output.
    * @return a new instance of StatelessRandomUniform
    */
-  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<V> statelessRandomUniform(
+  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniform<V> statelessRandomUniform(
       Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     return StatelessRandomUniform.create(scope, shape, seed, dtype);
   }
@@ -513,7 +512,7 @@ public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor
    * @param seed 2 seeds (shape [2]).
    * @return a new instance of StatelessTruncatedNormal
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<TFloat32> statelessTruncatedNormal(
+  public <T extends TNumber, U extends TNumber> StatelessTruncatedNormal<TFloat32> statelessTruncatedNormal(
       Operand<T> shape, Operand<U> seed) {
     return StatelessTruncatedNormal.create(scope, shape, seed);
   }
@@ -533,7 +532,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncat
    * @param dtype The type of the output.
    * @return a new instance of StatelessTruncatedNormal
    */
-  public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<V> statelessTruncatedNormal(
+  public <V extends TNumber, T extends TNumber, U extends TNumber> StatelessTruncatedNormal<V> statelessTruncatedNormal(
       Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     return StatelessTruncatedNormal.create(scope, shape, seed, dtype);
   }
@@ -551,8 +550,8 @@ public <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor
    * @param options carries optional attributes values
    * @return a new instance of TruncatedNormal
    */
-  public <U extends Tensor & TNumber, T extends Tensor & TNumber> TruncatedNormal<U> truncatedNormal(
-      Operand<T> shape, DataType<U> dtype, TruncatedNormal.Options... options) {
+  public <U extends TNumber, T extends TNumber> TruncatedNormal<U> truncatedNormal(Operand<T> shape,
+      DataType<U> dtype, TruncatedNormal.Options... options) {
     return TruncatedNormal.create(scope, shape, dtype, options);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java
index 077dd664c61..81c692571f1 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/ShapeOps.java
@@ -19,12 +19,12 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.core.Shape;
 import org.tensorflow.op.core.Shapes;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code shape} operations as {@link Op Op}s
@@ -78,8 +78,7 @@ public Operand<TInt32> append(Shape<TInt32> shape, int lastDimension) {
    *      operand representing a shape, followed by the dimensions of an operand representing a shape
    *      to append
    */
-  public <T extends Tensor & TNumber> Operand<T> append(Operand<T> shape,
-      Operand<T> shapeToAppend) {
+  public <T extends TNumber> Operand<T> append(Operand<T> shape, Operand<T> shapeToAppend) {
     return Shapes.append(scope, shape, shapeToAppend);
   }
 
@@ -91,7 +90,7 @@ public <T extends Tensor & TNumber> Operand<T> append(Operand<T> shape,
    * @param operand the operand to flatten
    * @return the reshaped operand
    */
-  public <T extends Tensor> Operand<T> flatten(Operand<T> operand) {
+  public <T extends TType> Operand<T> flatten(Operand<T> operand) {
     return Shapes.flatten(scope, operand);
   }
 
@@ -116,7 +115,7 @@ public Operand<TInt32> flatten(Shape<TInt32> shape) {
    * @param dType the shape datatype
    * @return the reshaped operand
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Operand<T> flatten(Operand<T> operand,
+  public <T extends TType, U extends TNumber> Operand<T> flatten(Operand<T> operand,
       DataType<U> dType) {
     return Shapes.flatten(scope, operand, dType);
   }
@@ -130,7 +129,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Operand<T> flatten(Operand
    * @param dType the shape datatype
    * @return the flattened shape
    */
-  public <U extends Tensor & TNumber> Operand<U> flatten(Shape<U> shape, DataType<U> dType) {
+  public <U extends TNumber> Operand<U> flatten(Shape<U> shape, DataType<U> dType) {
     return Shapes.flatten(scope, shape, dType);
   }
 
@@ -154,7 +153,7 @@ public Operand<TInt32> head(Shape<TInt32> shape) {
    * @param <U> the shape datatype.
    * @return a 1-dimensional Operand containing the Shape's first dimension
    */
-  public <U extends Tensor & TNumber> Operand<U> head(Shape<U> shape, DataType<U> dType) {
+  public <U extends TNumber> Operand<U> head(Shape<U> shape, DataType<U> dType) {
     return Shapes.head(scope, shape, dType);
   }
 
@@ -178,7 +177,7 @@ public Operand<TInt32> numDimensions(Shape<TInt32> shape) {
    * @param dType the shape datatype
    * @return the number of dimensions
    */
-  public <U extends Tensor & TNumber> Operand<U> numDimensions(Shape<U> shape, DataType<U> dType) {
+  public <U extends TNumber> Operand<U> numDimensions(Shape<U> shape, DataType<U> dType) {
     return Shapes.numDimensions(scope, shape, dType);
   }
 
@@ -222,8 +221,7 @@ public Operand<TInt32> prepend(Shape<TInt32> shape, int firstDimension) {
    *      operand representing the shape to prepend, followed by the dimensions of an operand
    *      representing the shape
    */
-  public <T extends Tensor & TNumber> Operand<T> prepend(Operand<T> shape,
-      Operand<T> shapeToPrepend) {
+  public <T extends TNumber> Operand<T> prepend(Operand<T> shape, Operand<T> shapeToPrepend) {
     return Shapes.prepend(scope, shape, shapeToPrepend);
   }
 
@@ -236,7 +234,7 @@ public <T extends Tensor & TNumber> Operand<T> prepend(Operand<T> shape,
    * @param axis the axis
    * @return the reshaped operand
    */
-  public <T extends Tensor> Operand<T> reduceDims(Operand<T> operand, Operand<TInt32> axis) {
+  public <T extends TType> Operand<T> reduceDims(Operand<T> operand, Operand<TInt32> axis) {
     return Shapes.reduceDims(scope, operand, axis);
   }
 
@@ -263,7 +261,7 @@ public Operand<TInt32> reduceDims(Shape<TInt32> shape, Operand<TInt32> axis) {
    * @param dType the shape datatype
    * @return the reshaped operand
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Operand<T> reduceDims(Operand<T> operand,
+  public <T extends TType, U extends TNumber> Operand<T> reduceDims(Operand<T> operand,
       Operand<U> axis, DataType<U> dType) {
     return Shapes.reduceDims(scope, operand, axis, dType);
   }
@@ -278,7 +276,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Operand<T> reduceDims(Oper
    * @param dType the shape datatype
    * @return the reduced shape
    */
-  public <U extends Tensor & TNumber> Operand<U> reduceDims(Shape<U> shape, Operand<U> axis,
+  public <U extends TNumber> Operand<U> reduceDims(Shape<U> shape, Operand<U> axis,
       DataType<U> dType) {
     return Shapes.reduceDims(scope, shape, axis, dType);
   }
@@ -302,7 +300,7 @@ public Operand<TInt32> size(Shape<TInt32> shape) {
    * @param dim the dimension
    * @return the size of the specified dimension
    */
-  public <T extends Tensor> Operand<TInt32> size(Operand<T> input, Operand<TInt32> dim) {
+  public <T extends TType> Operand<TInt32> size(Operand<T> input, Operand<TInt32> dim) {
     return Shapes.size(scope, input, dim);
   }
 
@@ -315,7 +313,7 @@ public <T extends Tensor> Operand<TInt32> size(Operand<T> input, Operand<TInt32>
    * @param dType the shape datatype
    * @return the size
    */
-  public <U extends Tensor & TNumber> Operand<U> size(Shape<U> shape, DataType<U> dType) {
+  public <U extends TNumber> Operand<U> size(Shape<U> shape, DataType<U> dType) {
     return Shapes.size(scope, shape, dType);
   }
 
@@ -341,8 +339,8 @@ public Operand<TInt32> size(Shape<TInt32> shape, Operand<TInt32> dim) {
    * @param dType the shape datatype
    * @return the size of the specified dimension
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Operand<U> size(Operand<T> input,
-      Operand<U> dim, DataType<U> dType) {
+  public <T extends TType, U extends TNumber> Operand<U> size(Operand<T> input, Operand<U> dim,
+      DataType<U> dType) {
     return Shapes.size(scope, input, dim, dType);
   }
 
@@ -356,8 +354,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Operand<U> size(Operand<T>
    * @param dType the shape datatype
    * @return the size of the specified dimension
    */
-  public <U extends Tensor & TNumber> Operand<U> size(Shape<U> shape, Operand<U> dim,
-      DataType<U> dType) {
+  public <U extends TNumber> Operand<U> size(Shape<U> shape, Operand<U> dim, DataType<U> dType) {
     return Shapes.size(scope, shape, dim, dType);
   }
 
@@ -381,7 +378,7 @@ public Operand<TInt32> squeeze(Shape<TInt32> shape) {
    * @param dType the shape datatype.
    * @return the squeezed shape
    */
-  public <U extends Tensor & TNumber> Operand<U> squeeze(Shape<U> shape, DataType<U> dType) {
+  public <U extends TNumber> Operand<U> squeeze(Shape<U> shape, DataType<U> dType) {
     return Shapes.squeeze(scope, shape, dType);
   }
 
@@ -409,7 +406,7 @@ public Operand<TInt32> tail(Shape<TInt32> shape) {
    * @return a 1-dimensional Operand that contains the dimension matching the last dimension of the
    *      Shape
    */
-  public <U extends Tensor & TNumber> Operand<U> tail(Shape<U> shape, DataType<U> dType) {
+  public <U extends TNumber> Operand<U> tail(Shape<U> shape, DataType<U> dType) {
     return Shapes.tail(scope, shape, dType);
   }
 
@@ -439,8 +436,7 @@ public Operand<TInt32> take(Shape<TInt32> shape, Operand<TInt32> n) {
    * @return a 1-dimensional operand with the dimensions matching * the first n dimensions of the
    *      shape
    */
-  public <U extends Tensor & TNumber> Operand<U> take(Shape<U> shape, Operand<U> n,
-      DataType<U> dType) {
+  public <U extends TNumber> Operand<U> take(Shape<U> shape, Operand<U> n, DataType<U> dType) {
     return Shapes.take(scope, shape, n, dType);
   }
 
@@ -454,8 +450,7 @@ public <U extends Tensor & TNumber> Operand<U> take(Shape<U> shape, Operand<U> n
    * @return a 1-dimensional operand containing the dimensions matching the last n dimensions of the
    *      shape
    */
-  public <U extends Tensor & TNumber> Operand<TInt32> takeLast(Shape<TInt32> shape,
-      Operand<TInt32> n) {
+  public <U extends TNumber> Operand<TInt32> takeLast(Shape<TInt32> shape, Operand<TInt32> n) {
     return Shapes.takeLast(scope, shape, n);
   }
 
@@ -471,8 +466,7 @@ public <U extends Tensor & TNumber> Operand<TInt32> takeLast(Shape<TInt32> shape
    * @return a 1-dimensional operand containing the dimensions matching the last n dimensions of the
    *      shape
    */
-  public <U extends Tensor & TNumber> Operand<U> takeLast(Shape<U> shape, Operand<U> n,
-      DataType<U> dType) {
+  public <U extends TNumber> Operand<U> takeLast(Shape<U> shape, Operand<U> n, DataType<U> dType) {
     return Shapes.takeLast(scope, shape, n, dType);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java
index c15b82120f0..f4ec7bdb48d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SignalOps.java
@@ -19,7 +19,6 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.signal.BatchFft;
 import org.tensorflow.op.signal.BatchFft2d;
 import org.tensorflow.op.signal.BatchFft3d;
@@ -41,6 +40,7 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code signal} operations as {@link Op Op}s
@@ -118,7 +118,7 @@ public BatchIfft3d batchIfft3d(Operand<?> input) {
    * @param input A complex tensor.
    * @return a new instance of Fft
    */
-  public <T extends Tensor> Fft<T> fft(Operand<T> input) {
+  public <T extends TType> Fft<T> fft(Operand<T> input) {
     return Fft.create(scope, input);
   }
 
@@ -132,7 +132,7 @@ public <T extends Tensor> Fft<T> fft(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Fft2d
    */
-  public <T extends Tensor> Fft2d<T> fft2d(Operand<T> input) {
+  public <T extends TType> Fft2d<T> fft2d(Operand<T> input) {
     return Fft2d.create(scope, input);
   }
 
@@ -146,7 +146,7 @@ public <T extends Tensor> Fft2d<T> fft2d(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Fft3d
    */
-  public <T extends Tensor> Fft3d<T> fft3d(Operand<T> input) {
+  public <T extends TType> Fft3d<T> fft3d(Operand<T> input) {
     return Fft3d.create(scope, input);
   }
 
@@ -160,7 +160,7 @@ public <T extends Tensor> Fft3d<T> fft3d(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Ifft
    */
-  public <T extends Tensor> Ifft<T> ifft(Operand<T> input) {
+  public <T extends TType> Ifft<T> ifft(Operand<T> input) {
     return Ifft.create(scope, input);
   }
 
@@ -174,7 +174,7 @@ public <T extends Tensor> Ifft<T> ifft(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Ifft2d
    */
-  public <T extends Tensor> Ifft2d<T> ifft2d(Operand<T> input) {
+  public <T extends TType> Ifft2d<T> ifft2d(Operand<T> input) {
     return Ifft2d.create(scope, input);
   }
 
@@ -188,7 +188,7 @@ public <T extends Tensor> Ifft2d<T> ifft2d(Operand<T> input) {
    * @param input A complex tensor.
    * @return a new instance of Ifft3d
    */
-  public <T extends Tensor> Ifft3d<T> ifft3d(Operand<T> input) {
+  public <T extends TType> Ifft3d<T> ifft3d(Operand<T> input) {
     return Ifft3d.create(scope, input);
   }
 
@@ -214,7 +214,7 @@ public <T extends Tensor> Ifft3d<T> ifft3d(Operand<T> input) {
    * @param fftLength An int32 tensor of shape [1]. The FFT length.
    * @return a new instance of Irfft
    */
-  public <T extends Tensor> Irfft<TFloat32> irfft(Operand<T> input, Operand<TInt32> fftLength) {
+  public <T extends TType> Irfft<TFloat32> irfft(Operand<T> input, Operand<TInt32> fftLength) {
     return Irfft.create(scope, input, fftLength);
   }
 
@@ -241,7 +241,7 @@ public <T extends Tensor> Irfft<TFloat32> irfft(Operand<T> input, Operand<TInt32
    * @param Treal
    * @return a new instance of Irfft
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Irfft<U> irfft(Operand<T> input,
+  public <U extends TNumber, T extends TType> Irfft<U> irfft(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Treal) {
     return Irfft.create(scope, input, fftLength, Treal);
   }
@@ -269,7 +269,7 @@ public <U extends Tensor & TNumber, T extends Tensor> Irfft<U> irfft(Operand<T>
    * @param fftLength An int32 tensor of shape [2]. The FFT length for each dimension.
    * @return a new instance of Irfft2d
    */
-  public <T extends Tensor> Irfft2d<TFloat32> irfft2d(Operand<T> input, Operand<TInt32> fftLength) {
+  public <T extends TType> Irfft2d<TFloat32> irfft2d(Operand<T> input, Operand<TInt32> fftLength) {
     return Irfft2d.create(scope, input, fftLength);
   }
 
@@ -297,7 +297,7 @@ public <T extends Tensor> Irfft2d<TFloat32> irfft2d(Operand<T> input, Operand<TI
    * @param Treal
    * @return a new instance of Irfft2d
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Irfft2d<U> irfft2d(Operand<T> input,
+  public <U extends TNumber, T extends TType> Irfft2d<U> irfft2d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Treal) {
     return Irfft2d.create(scope, input, fftLength, Treal);
   }
@@ -325,7 +325,7 @@ public <U extends Tensor & TNumber, T extends Tensor> Irfft2d<U> irfft2d(Operand
    * @param fftLength An int32 tensor of shape [3]. The FFT length for each dimension.
    * @return a new instance of Irfft3d
    */
-  public <T extends Tensor> Irfft3d<TFloat32> irfft3d(Operand<T> input, Operand<TInt32> fftLength) {
+  public <T extends TType> Irfft3d<TFloat32> irfft3d(Operand<T> input, Operand<TInt32> fftLength) {
     return Irfft3d.create(scope, input, fftLength);
   }
 
@@ -353,7 +353,7 @@ public <T extends Tensor> Irfft3d<TFloat32> irfft3d(Operand<T> input, Operand<TI
    * @param Treal
    * @return a new instance of Irfft3d
    */
-  public <U extends Tensor & TNumber, T extends Tensor> Irfft3d<U> irfft3d(Operand<T> input,
+  public <U extends TNumber, T extends TType> Irfft3d<U> irfft3d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Treal) {
     return Irfft3d.create(scope, input, fftLength, Treal);
   }
@@ -378,7 +378,7 @@ public <U extends Tensor & TNumber, T extends Tensor> Irfft3d<U> irfft3d(Operand
    * @param Tcomplex
    * @return a new instance of Rfft
    */
-  public <U extends Tensor, T extends Tensor & TNumber> Rfft<U> rfft(Operand<T> input,
+  public <U extends TType, T extends TNumber> Rfft<U> rfft(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     return Rfft.create(scope, input, fftLength, Tcomplex);
   }
@@ -404,7 +404,7 @@ public <U extends Tensor, T extends Tensor & TNumber> Rfft<U> rfft(Operand<T> in
    * @param Tcomplex
    * @return a new instance of Rfft2d
    */
-  public <U extends Tensor, T extends Tensor & TNumber> Rfft2d<U> rfft2d(Operand<T> input,
+  public <U extends TType, T extends TNumber> Rfft2d<U> rfft2d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     return Rfft2d.create(scope, input, fftLength, Tcomplex);
   }
@@ -430,7 +430,7 @@ public <U extends Tensor, T extends Tensor & TNumber> Rfft2d<U> rfft2d(Operand<T
    * @param Tcomplex
    * @return a new instance of Rfft3d
    */
-  public <U extends Tensor, T extends Tensor & TNumber> Rfft3d<U> rfft3d(Operand<T> input,
+  public <U extends TType, T extends TNumber> Rfft3d<U> rfft3d(Operand<T> input,
       Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     return Rfft3d.create(scope, input, fftLength, Tcomplex);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java
index d8ba9f45ef2..6e26fec2275 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SparseOps.java
@@ -19,7 +19,6 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.sparse.AddManySparseToTensorsMap;
 import org.tensorflow.op.sparse.AddSparseToTensorsMap;
@@ -68,6 +67,7 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code sparse} operations as {@link Op Op}s
@@ -114,7 +114,7 @@ public final class SparseOps {
    * @param options carries optional attributes values
    * @return a new instance of AddManySparseToTensorsMap
    */
-  public <T extends Tensor> AddManySparseToTensorsMap addManySparseToTensorsMap(
+  public <T extends TType> AddManySparseToTensorsMap addManySparseToTensorsMap(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       AddManySparseToTensorsMap.Options... options) {
     return AddManySparseToTensorsMap.create(scope, sparseIndices, sparseValues, sparseShape, options);
@@ -144,7 +144,7 @@ public <T extends Tensor> AddManySparseToTensorsMap addManySparseToTensorsMap(
    * @param options carries optional attributes values
    * @return a new instance of AddSparseToTensorsMap
    */
-  public <T extends Tensor> AddSparseToTensorsMap addSparseToTensorsMap(
+  public <T extends TType> AddSparseToTensorsMap addSparseToTensorsMap(
       Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape,
       AddSparseToTensorsMap.Options... options) {
     return AddSparseToTensorsMap.create(scope, sparseIndices, sparseValues, sparseShape, options);
@@ -170,7 +170,7 @@ public <T extends Tensor> AddSparseToTensorsMap addSparseToTensorsMap(
    * @param options carries optional attributes values
    * @return a new instance of DenseToDenseSetOperation
    */
-  public <T extends Tensor> DenseToDenseSetOperation<T> denseToDenseSetOperation(Operand<T> set1,
+  public <T extends TType> DenseToDenseSetOperation<T> denseToDenseSetOperation(Operand<T> set1,
       Operand<T> set2, String setOperation, DenseToDenseSetOperation.Options... options) {
     return DenseToDenseSetOperation.create(scope, set1, set2, setOperation, options);
   }
@@ -208,7 +208,7 @@ public <T extends Tensor> DenseToDenseSetOperation<T> denseToDenseSetOperation(O
    * @param options carries optional attributes values
    * @return a new instance of DenseToSparseSetOperation
    */
-  public <T extends Tensor> DenseToSparseSetOperation<T> denseToSparseSetOperation(Operand<T> set1,
+  public <T extends TType> DenseToSparseSetOperation<T> denseToSparseSetOperation(Operand<T> set1,
       Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape,
       String setOperation, DenseToSparseSetOperation.Options... options) {
     return DenseToSparseSetOperation.create(scope, set1, set2Indices, set2Values, set2Shape, setOperation, options);
@@ -265,7 +265,7 @@ public <T extends Tensor> DenseToSparseSetOperation<T> denseToSparseSetOperation
    * @param dtype The `dtype` of the serialized `SparseTensor` objects.
    * @return a new instance of DeserializeSparse
    */
-  public <U extends Tensor, T extends Tensor> DeserializeSparse<U> deserializeSparse(
+  public <U extends TType, T extends TType> DeserializeSparse<U> deserializeSparse(
       Operand<T> serializedSparse, DataType<U> dtype) {
     return DeserializeSparse.create(scope, serializedSparse, dtype);
   }
@@ -288,7 +288,7 @@ public <U extends Tensor, T extends Tensor> DeserializeSparse<U> deserializeSpar
    *  case the input is ignored during validation.
    * @return a new instance of SparseAccumulatorApplyGradient
    */
-  public <T extends Tensor> SparseAccumulatorApplyGradient sparseAccumulatorApplyGradient(
+  public <T extends TType> SparseAccumulatorApplyGradient sparseAccumulatorApplyGradient(
       Operand<TString> handle, Operand<TInt64> localStep, Operand<TInt64> gradientIndices,
       Operand<T> gradientValues, Operand<TInt64> gradientShape, Boolean hasKnownShape) {
     return SparseAccumulatorApplyGradient.create(scope, handle, localStep, gradientIndices, gradientValues, gradientShape, hasKnownShape);
@@ -311,7 +311,7 @@ public <T extends Tensor> SparseAccumulatorApplyGradient sparseAccumulatorApplyG
    *  of the accumulator.
    * @return a new instance of SparseAccumulatorTakeGradient
    */
-  public <T extends Tensor> SparseAccumulatorTakeGradient<T> sparseAccumulatorTakeGradient(
+  public <T extends TType> SparseAccumulatorTakeGradient<T> sparseAccumulatorTakeGradient(
       Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     return SparseAccumulatorTakeGradient.create(scope, handle, numRequired, dtype);
   }
@@ -344,9 +344,9 @@ public <T extends Tensor> SparseAccumulatorTakeGradient<T> sparseAccumulatorTake
    *  pair takes space.
    * @return a new instance of SparseAdd
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseAdd<T> sparseAdd(
-      Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape,
-      Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape, Operand<U> thresh) {
+  public <T extends TType, U extends TNumber> SparseAdd<T> sparseAdd(Operand<TInt64> aIndices,
+      Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues,
+      Operand<TInt64> bShape, Operand<U> thresh) {
     return SparseAdd.create(scope, aIndices, aValues, aShape, bIndices, bValues, bShape, thresh);
   }
 
@@ -367,7 +367,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseAdd<T> sparseAdd(
    *  `[nnz(sum), ndims]`.
    * @return a new instance of SparseAddGrad
    */
-  public <T extends Tensor> SparseAddGrad<T> sparseAddGrad(Operand<T> backpropValGrad,
+  public <T extends TType> SparseAddGrad<T> sparseAddGrad(Operand<T> backpropValGrad,
       Operand<TInt64> aIndices, Operand<TInt64> bIndices, Operand<TInt64> sumIndices) {
     return SparseAddGrad.create(scope, backpropValGrad, aIndices, bIndices, sumIndices);
   }
@@ -425,7 +425,7 @@ public <T extends Tensor> SparseAddGrad<T> sparseAddGrad(Operand<T> backpropValG
    *  where rank is the number of dimensions in each input `SparseTensor`.
    * @return a new instance of SparseConcat
    */
-  public <T extends Tensor> SparseConcat<T> sparseConcat(Iterable<Operand<TInt64>> indices,
+  public <T extends TType> SparseConcat<T> sparseConcat(Iterable<Operand<TInt64>> indices,
       Iterable<Operand<T>> values, Iterable<Operand<TInt64>> shapes, Long concatDim) {
     return SparseConcat.create(scope, indices, values, shapes, concatDim);
   }
@@ -445,7 +445,7 @@ public <T extends Tensor> SparseConcat<T> sparseConcat(Iterable<Operand<TInt64>>
    * @param options carries optional attributes values
    * @return a new instance of SparseConditionalAccumulator
    */
-  public <T extends Tensor> SparseConditionalAccumulator sparseConditionalAccumulator(
+  public <T extends TType> SparseConditionalAccumulator sparseConditionalAccumulator(
       DataType<T> dtype, Shape shape, SparseConditionalAccumulator.Options... options) {
     return SparseConditionalAccumulator.create(scope, dtype, shape, options);
   }
@@ -505,7 +505,7 @@ public <T extends Tensor> SparseConditionalAccumulator sparseConditionalAccumula
    * @param internalType
    * @return a new instance of SparseCross
    */
-  public <T extends Tensor, U extends Tensor> SparseCross<T> sparseCross(
+  public <T extends TType, U extends TType> SparseCross<T> sparseCross(
       Iterable<Operand<TInt64>> indices, Iterable<Operand<?>> values,
       Iterable<Operand<TInt64>> shapes, Iterable<Operand<?>> denseInputs, Boolean hashedOutput,
       Long numBuckets, Long hashKey, DataType<T> outType, DataType<U> internalType) {
@@ -532,7 +532,7 @@ public <T extends Tensor, U extends Tensor> SparseCross<T> sparseCross(
    * @param dense `R`-D.  The dense Tensor operand.
    * @return a new instance of SparseDenseCwiseAdd
    */
-  public <T extends Tensor> SparseDenseCwiseAdd<T> sparseDenseCwiseAdd(Operand<TInt64> spIndices,
+  public <T extends TType> SparseDenseCwiseAdd<T> sparseDenseCwiseAdd(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     return SparseDenseCwiseAdd.create(scope, spIndices, spValues, spShape, dense);
   }
@@ -551,7 +551,7 @@ public <T extends Tensor> SparseDenseCwiseAdd<T> sparseDenseCwiseAdd(Operand<TIn
    * @param dense `R`-D.  The dense Tensor operand.
    * @return a new instance of SparseDenseCwiseDiv
    */
-  public <T extends Tensor> SparseDenseCwiseDiv<T> sparseDenseCwiseDiv(Operand<TInt64> spIndices,
+  public <T extends TType> SparseDenseCwiseDiv<T> sparseDenseCwiseDiv(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     return SparseDenseCwiseDiv.create(scope, spIndices, spValues, spShape, dense);
   }
@@ -574,7 +574,7 @@ public <T extends Tensor> SparseDenseCwiseDiv<T> sparseDenseCwiseDiv(Operand<TIn
    * @param dense `R`-D.  The dense Tensor operand.
    * @return a new instance of SparseDenseCwiseMul
    */
-  public <T extends Tensor> SparseDenseCwiseMul<T> sparseDenseCwiseMul(Operand<TInt64> spIndices,
+  public <T extends TType> SparseDenseCwiseMul<T> sparseDenseCwiseMul(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     return SparseDenseCwiseMul.create(scope, spIndices, spValues, spShape, dense);
   }
@@ -628,7 +628,7 @@ public <T extends Tensor> SparseDenseCwiseMul<T> sparseDenseCwiseMul(Operand<TIn
    *  output indices: 2-D. the indices of the filled sparse tensor.
    * @return a new instance of SparseFillEmptyRows
    */
-  public <T extends Tensor> SparseFillEmptyRows<T> sparseFillEmptyRows(Operand<TInt64> indices,
+  public <T extends TType> SparseFillEmptyRows<T> sparseFillEmptyRows(Operand<TInt64> indices,
       Operand<T> values, Operand<TInt64> denseShape, Operand<T> defaultValue) {
     return SparseFillEmptyRows.create(scope, indices, values, denseShape, defaultValue);
   }
@@ -650,7 +650,7 @@ public <T extends Tensor> SparseFillEmptyRows<T> sparseFillEmptyRows(Operand<TIn
    * @param gradValues 1-D.  The gradients from backprop.
    * @return a new instance of SparseFillEmptyRowsGrad
    */
-  public <T extends Tensor> SparseFillEmptyRowsGrad<T> sparseFillEmptyRowsGrad(
+  public <T extends TType> SparseFillEmptyRowsGrad<T> sparseFillEmptyRowsGrad(
       Operand<TInt64> reverseIndexMap, Operand<T> gradValues) {
     return SparseFillEmptyRowsGrad.create(scope, reverseIndexMap, gradValues);
   }
@@ -673,8 +673,8 @@ public <T extends Tensor> SparseFillEmptyRowsGrad<T> sparseFillEmptyRowsGrad(
    * @param options carries optional attributes values
    * @return a new instance of SparseMatMul
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseMatMul sparseMatMul(
-      Operand<T> a, Operand<U> b, SparseMatMul.Options... options) {
+  public <T extends TNumber, U extends TNumber> SparseMatMul sparseMatMul(Operand<T> a,
+      Operand<U> b, SparseMatMul.Options... options) {
     return SparseMatMul.create(scope, a, b, options);
   }
 
@@ -703,9 +703,9 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseMatMul spa
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceMax
    */
-  public <T extends Tensor & TNumber> SparseReduceMax<T> sparseReduceMax(
-      Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape,
-      Operand<TInt32> reductionAxes, SparseReduceMax.Options... options) {
+  public <T extends TNumber> SparseReduceMax<T> sparseReduceMax(Operand<TInt64> inputIndices,
+      Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes,
+      SparseReduceMax.Options... options) {
     return SparseReduceMax.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
   }
 
@@ -734,7 +734,7 @@ public <T extends Tensor & TNumber> SparseReduceMax<T> sparseReduceMax(
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceMaxSparse
    */
-  public <T extends Tensor & TNumber> SparseReduceMaxSparse<T> sparseReduceMaxSparse(
+  public <T extends TNumber> SparseReduceMaxSparse<T> sparseReduceMaxSparse(
       Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape,
       Operand<TInt32> reductionAxes, SparseReduceMaxSparse.Options... options) {
     return SparseReduceMaxSparse.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
@@ -765,7 +765,7 @@ public <T extends Tensor & TNumber> SparseReduceMaxSparse<T> sparseReduceMaxSpar
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceSum
    */
-  public <T extends Tensor> SparseReduceSum<T> sparseReduceSum(Operand<TInt64> inputIndices,
+  public <T extends TType> SparseReduceSum<T> sparseReduceSum(Operand<TInt64> inputIndices,
       Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes,
       SparseReduceSum.Options... options) {
     return SparseReduceSum.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
@@ -796,7 +796,7 @@ public <T extends Tensor> SparseReduceSum<T> sparseReduceSum(Operand<TInt64> inp
    * @param options carries optional attributes values
    * @return a new instance of SparseReduceSumSparse
    */
-  public <T extends Tensor> SparseReduceSumSparse<T> sparseReduceSumSparse(
+  public <T extends TType> SparseReduceSumSparse<T> sparseReduceSumSparse(
       Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape,
       Operand<TInt32> reductionAxes, SparseReduceSumSparse.Options... options) {
     return SparseReduceSumSparse.create(scope, inputIndices, inputValues, inputShape, reductionAxes, options);
@@ -821,7 +821,7 @@ public <T extends Tensor> SparseReduceSumSparse<T> sparseReduceSumSparse(
    * @param inputShape 1-D.  Shape of the input SparseTensor.
    * @return a new instance of SparseReorder
    */
-  public <T extends Tensor> SparseReorder<T> sparseReorder(Operand<TInt64> inputIndices,
+  public <T extends TType> SparseReorder<T> sparseReorder(Operand<TInt64> inputIndices,
       Operand<T> inputValues, Operand<TInt64> inputShape) {
     return SparseReorder.create(scope, inputIndices, inputValues, inputShape);
   }
@@ -870,7 +870,7 @@ public SparseReshape sparseReshape(Operand<TInt64> inputIndices, Operand<TInt64>
    * @param segmentIds A 1-D tensor. Values should be sorted and can be repeated.
    * @return a new instance of SparseSegmentMean
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMean<T> sparseSegmentMean(
+  public <T extends TNumber, U extends TNumber> SparseSegmentMean<T> sparseSegmentMean(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     return SparseSegmentMean.create(scope, data, indices, segmentIds);
   }
@@ -888,7 +888,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMea
    * @param outputDim0 dimension 0 of "data" passed to SparseSegmentMean op.
    * @return a new instance of SparseSegmentMeanGrad
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMeanGrad<T> sparseSegmentMeanGrad(
+  public <T extends TNumber, U extends TNumber> SparseSegmentMeanGrad<T> sparseSegmentMeanGrad(
       Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     return SparseSegmentMeanGrad.create(scope, grad, indices, segmentIds, outputDim0);
   }
@@ -910,7 +910,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMea
    * @param numSegments Should equal the number of distinct segment IDs.
    * @return a new instance of SparseSegmentMeanWithNumSegments
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentMeanWithNumSegments<T> sparseSegmentMeanWithNumSegments(
+  public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentMeanWithNumSegments<T> sparseSegmentMeanWithNumSegments(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     return SparseSegmentMeanWithNumSegments.create(scope, data, indices, segmentIds, numSegments);
   }
@@ -928,7 +928,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor
    * @param segmentIds A 1-D tensor. Values should be sorted and can be repeated.
    * @return a new instance of SparseSegmentSqrtN
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtN<T> sparseSegmentSqrtN(
+  public <T extends TNumber, U extends TNumber> SparseSegmentSqrtN<T> sparseSegmentSqrtN(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     return SparseSegmentSqrtN.create(scope, data, indices, segmentIds);
   }
@@ -946,7 +946,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqr
    * @param outputDim0 dimension 0 of "data" passed to SparseSegmentSqrtN op.
    * @return a new instance of SparseSegmentSqrtNGrad
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtNGrad<T> sparseSegmentSqrtNGrad(
+  public <T extends TNumber, U extends TNumber> SparseSegmentSqrtNGrad<T> sparseSegmentSqrtNGrad(
       Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     return SparseSegmentSqrtNGrad.create(scope, grad, indices, segmentIds, outputDim0);
   }
@@ -970,7 +970,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqr
    * @param numSegments Should equal the number of distinct segment IDs.
    * @return a new instance of SparseSegmentSqrtNWithNumSegments
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSqrtNWithNumSegments<T> sparseSegmentSqrtNWithNumSegments(
+  public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSqrtNWithNumSegments<T> sparseSegmentSqrtNWithNumSegments(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     return SparseSegmentSqrtNWithNumSegments.create(scope, data, indices, segmentIds, numSegments);
   }
@@ -1013,7 +1013,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor
    * @param segmentIds A 1-D tensor. Values should be sorted and can be repeated.
    * @return a new instance of SparseSegmentSum
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSum<T> sparseSegmentSum(
+  public <T extends TNumber, U extends TNumber> SparseSegmentSum<T> sparseSegmentSum(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     return SparseSegmentSum.create(scope, data, indices, segmentIds);
   }
@@ -1055,7 +1055,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSum
    * @param numSegments Should equal the number of distinct segment IDs.
    * @return a new instance of SparseSegmentSumWithNumSegments
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSumWithNumSegments<T> sparseSegmentSumWithNumSegments(
+  public <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSumWithNumSegments<T> sparseSegmentSumWithNumSegments(
       Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     return SparseSegmentSumWithNumSegments.create(scope, data, indices, segmentIds, numSegments);
   }
@@ -1089,7 +1089,7 @@ public <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor
    *  sparse tensors.
    * @return a new instance of SparseSlice
    */
-  public <T extends Tensor> SparseSlice<T> sparseSlice(Operand<TInt64> indices, Operand<T> values,
+  public <T extends TType> SparseSlice<T> sparseSlice(Operand<TInt64> indices, Operand<T> values,
       Operand<TInt64> shape, Operand<TInt64> start, Operand<TInt64> size) {
     return SparseSlice.create(scope, indices, values, shape, start, size);
   }
@@ -1109,7 +1109,7 @@ public <T extends Tensor> SparseSlice<T> sparseSlice(Operand<TInt64> indices, Op
    * @param outputIndices 2-D.  The `indices` of the sliced `SparseTensor`.
    * @return a new instance of SparseSliceGrad
    */
-  public <T extends Tensor> SparseSliceGrad<T> sparseSliceGrad(Operand<T> backpropValGrad,
+  public <T extends TType> SparseSliceGrad<T> sparseSliceGrad(Operand<T> backpropValGrad,
       Operand<TInt64> inputIndices, Operand<TInt64> inputStart, Operand<TInt64> outputIndices) {
     return SparseSliceGrad.create(scope, backpropValGrad, inputIndices, inputStart, outputIndices);
   }
@@ -1140,7 +1140,7 @@ public <T extends Tensor> SparseSliceGrad<T> sparseSliceGrad(Operand<T> backprop
    * @param spShape 1-D.  Shape of the input SparseTensor.
    * @return a new instance of SparseSoftmax
    */
-  public <T extends Tensor & TNumber> SparseSoftmax<T> sparseSoftmax(Operand<TInt64> spIndices,
+  public <T extends TNumber> SparseSoftmax<T> sparseSoftmax(Operand<TInt64> spIndices,
       Operand<T> spValues, Operand<TInt64> spShape) {
     return SparseSoftmax.create(scope, spIndices, spValues, spShape);
   }
@@ -1160,9 +1160,9 @@ public <T extends Tensor & TNumber> SparseSoftmax<T> sparseSoftmax(Operand<TInt6
    * @param bShape counterpart to `a_shape` for the other operand; the two shapes must be equal.
    * @return a new instance of SparseSparseMaximum
    */
-  public <T extends Tensor & TNumber> SparseSparseMaximum<T> sparseSparseMaximum(
-      Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape,
-      Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
+  public <T extends TNumber> SparseSparseMaximum<T> sparseSparseMaximum(Operand<TInt64> aIndices,
+      Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues,
+      Operand<TInt64> bShape) {
     return SparseSparseMaximum.create(scope, aIndices, aValues, aShape, bIndices, bValues, bShape);
   }
 
@@ -1181,7 +1181,7 @@ public <T extends Tensor & TNumber> SparseSparseMaximum<T> sparseSparseMaximum(
    * @param bShape counterpart to `a_shape` for the other operand; the two shapes must be equal.
    * @return a new instance of SparseSparseMinimum
    */
-  public <T extends Tensor> SparseSparseMinimum<T> sparseSparseMinimum(Operand<TInt64> aIndices,
+  public <T extends TType> SparseSparseMinimum<T> sparseSparseMinimum(Operand<TInt64> aIndices,
       Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues,
       Operand<TInt64> bShape) {
     return SparseSparseMinimum.create(scope, aIndices, aValues, aShape, bIndices, bValues, bShape);
@@ -1219,7 +1219,7 @@ public <T extends Tensor> SparseSparseMinimum<T> sparseSparseMinimum(Operand<TIn
    * @param numSplit The number of ways to split.
    * @return a new instance of SparseSplit
    */
-  public <T extends Tensor> SparseSplit<T> sparseSplit(Operand<TInt64> splitDim,
+  public <T extends TType> SparseSplit<T> sparseSplit(Operand<TInt64> splitDim,
       Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Long numSplit) {
     return SparseSplit.create(scope, splitDim, indices, values, shape, numSplit);
   }
@@ -1236,7 +1236,7 @@ public <T extends Tensor> SparseSplit<T> sparseSplit(Operand<TInt64> splitDim,
    * @param b `ndims`-D Tensor.  With shape `a_shape`.
    * @return a new instance of SparseTensorDenseAdd
    */
-  public <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseAdd<U> sparseTensorDenseAdd(
+  public <U extends TType, T extends TNumber> SparseTensorDenseAdd<U> sparseTensorDenseAdd(
       Operand<T> aIndices, Operand<U> aValues, Operand<T> aShape, Operand<U> b) {
     return SparseTensorDenseAdd.create(scope, aIndices, aValues, aShape, b);
   }
@@ -1262,7 +1262,7 @@ public <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseAdd<U> sp
    * @param options carries optional attributes values
    * @return a new instance of SparseTensorDenseMatMul
    */
-  public <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseMatMul<U> sparseTensorDenseMatMul(
+  public <U extends TType, T extends TNumber> SparseTensorDenseMatMul<U> sparseTensorDenseMatMul(
       Operand<T> aIndices, Operand<U> aValues, Operand<TInt64> aShape, Operand<U> b,
       SparseTensorDenseMatMul.Options... options) {
     return SparseTensorDenseMatMul.create(scope, aIndices, aValues, aShape, b, options);
@@ -1300,7 +1300,7 @@ public <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseMatMul<U>
    * @param options carries optional attributes values
    * @return a new instance of SparseToDense
    */
-  public <U extends Tensor, T extends Tensor & TNumber> SparseToDense<U> sparseToDense(
+  public <U extends TType, T extends TNumber> SparseToDense<U> sparseToDense(
       Operand<T> sparseIndices, Operand<T> outputShape, Operand<U> sparseValues,
       Operand<U> defaultValue, SparseToDense.Options... options) {
     return SparseToDense.create(scope, sparseIndices, outputShape, sparseValues, defaultValue, options);
@@ -1352,7 +1352,7 @@ public <U extends Tensor, T extends Tensor & TNumber> SparseToDense<U> sparseToD
    * @param options carries optional attributes values
    * @return a new instance of SparseToSparseSetOperation
    */
-  public <T extends Tensor> SparseToSparseSetOperation<T> sparseToSparseSetOperation(
+  public <T extends TType> SparseToSparseSetOperation<T> sparseToSparseSetOperation(
       Operand<TInt64> set1Indices, Operand<T> set1Values, Operand<TInt64> set1Shape,
       Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape,
       String setOperation, SparseToSparseSetOperation.Options... options) {
@@ -1414,7 +1414,7 @@ public <T extends Tensor> SparseToSparseSetOperation<T> sparseToSparseSetOperati
    * @param options carries optional attributes values
    * @return a new instance of TakeManySparseFromTensorsMap
    */
-  public <T extends Tensor> TakeManySparseFromTensorsMap<T> takeManySparseFromTensorsMap(
+  public <T extends TType> TakeManySparseFromTensorsMap<T> takeManySparseFromTensorsMap(
       Operand<TInt64> sparseHandles, DataType<T> dtype,
       TakeManySparseFromTensorsMap.Options... options) {
     return TakeManySparseFromTensorsMap.create(scope, sparseHandles, dtype, options);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java
index 7b0fca54355..75659ed60be 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/StringsOps.java
@@ -20,7 +20,6 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.strings.Join;
 import org.tensorflow.op.strings.Lower;
 import org.tensorflow.op.strings.ReduceJoin;
@@ -231,7 +230,7 @@ public StringLength stringLength(Operand<TString> input, StringLength.Options...
    * @param preserveShortSequences
    * @return a new instance of StringNGrams
    */
-  public <T extends Tensor & TNumber> StringNGrams<T> stringNGrams(Operand<TString> data,
+  public <T extends TNumber> StringNGrams<T> stringNGrams(Operand<TString> data,
       Operand<T> dataSplits, String separator, List<Long> ngramWidths, String leftPad,
       String rightPad, Long padWidth, Boolean preserveShortSequences) {
     return StringNGrams.create(scope, data, dataSplits, separator, ngramWidths, leftPad, rightPad, padWidth, preserveShortSequences);
@@ -368,8 +367,8 @@ public Strip strip(Operand<TString> input) {
    * @param options carries optional attributes values
    * @return a new instance of Substr
    */
-  public <T extends Tensor & TNumber> Substr substr(Operand<TString> input, Operand<T> pos,
-      Operand<T> len, Substr.Options... options) {
+  public <T extends TNumber> Substr substr(Operand<TString> input, Operand<T> pos, Operand<T> len,
+      Substr.Options... options) {
     return Substr.create(scope, input, pos, len, options);
   }
 
@@ -484,7 +483,7 @@ public ToNumber<TFloat32> toNumber(Operand<TString> stringTensor) {
    * @param outType The numeric type to interpret each string in `string_tensor` as.
    * @return a new instance of ToNumber
    */
-  public <T extends Tensor & TNumber> ToNumber<T> toNumber(Operand<TString> stringTensor,
+  public <T extends TNumber> ToNumber<T> toNumber(Operand<TString> stringTensor,
       DataType<T> outType) {
     return ToNumber.create(scope, stringTensor, outType);
   }
@@ -597,7 +596,7 @@ public UnicodeTranscode unicodeTranscode(Operand<TString> input, String inputEnc
    * @param options carries optional attributes values
    * @return a new instance of UnsortedSegmentJoin
    */
-  public <T extends Tensor & TNumber, U extends Tensor & TNumber> UnsortedSegmentJoin unsortedSegmentJoin(
+  public <T extends TNumber, U extends TNumber> UnsortedSegmentJoin unsortedSegmentJoin(
       Operand<TString> inputs, Operand<T> segmentIds, Operand<U> numSegments,
       UnsortedSegmentJoin.Options... options) {
     return UnsortedSegmentJoin.create(scope, inputs, segmentIds, numSegments, options);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java
index ce8b445610d..6143335b8fd 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/SummaryOps.java
@@ -18,7 +18,6 @@
 package org.tensorflow.op;
 
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.summary.AudioSummary;
 import org.tensorflow.op.summary.HistogramSummary;
 import org.tensorflow.op.summary.ImageSummary;
@@ -28,6 +27,7 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code summary} operations as {@link Op Op}s
@@ -83,7 +83,7 @@ public AudioSummary audioSummary(Operand<TString> tag, Operand<TFloat32> tensor,
    * @param values Any shape. Values to use to build the histogram.
    * @return a new instance of HistogramSummary
    */
-  public <T extends Tensor & TNumber> HistogramSummary histogramSummary(Operand<TString> tag,
+  public <T extends TNumber> HistogramSummary histogramSummary(Operand<TString> tag,
       Operand<T> values) {
     return HistogramSummary.create(scope, tag, values);
   }
@@ -144,8 +144,8 @@ public <T extends Tensor & TNumber> HistogramSummary histogramSummary(Operand<TS
    * @param options carries optional attributes values
    * @return a new instance of ImageSummary
    */
-  public <T extends Tensor & TNumber> ImageSummary imageSummary(Operand<TString> tag,
-      Operand<T> tensor, ImageSummary.Options... options) {
+  public <T extends TNumber> ImageSummary imageSummary(Operand<TString> tag, Operand<T> tensor,
+      ImageSummary.Options... options) {
     return ImageSummary.create(scope, tag, tensor, options);
   }
 
@@ -178,8 +178,7 @@ public MergeSummary mergeSummary(Iterable<Operand<TString>> inputs) {
    * @param values Same shape as `tags.  Values for the summary.
    * @return a new instance of ScalarSummary
    */
-  public <T extends Tensor & TNumber> ScalarSummary scalarSummary(Operand<TString> tags,
-      Operand<T> values) {
+  public <T extends TNumber> ScalarSummary scalarSummary(Operand<TString> tags, Operand<T> values) {
     return ScalarSummary.create(scope, tags, values);
   }
 
@@ -192,7 +191,7 @@ public <T extends Tensor & TNumber> ScalarSummary scalarSummary(Operand<TString>
    *  data.
    * @return a new instance of TensorSummary
    */
-  public <T extends Tensor> TensorSummary tensorSummary(Operand<TString> tag, Operand<T> tensor,
+  public <T extends TType> TensorSummary tensorSummary(Operand<TString> tag, Operand<T> tensor,
       Operand<TString> serializedSummaryMetadata) {
     return TensorSummary.create(scope, tag, tensor, serializedSummaryMetadata);
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java
index 335dba78fb2..daf89645f2c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/TrainOps.java
@@ -20,7 +20,6 @@
 import java.util.List;
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.train.AccumulatorApplyGradient;
 import org.tensorflow.op.train.AccumulatorNumAccumulated;
@@ -89,6 +88,7 @@
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code train} operations as {@link Op Op}s
@@ -112,7 +112,7 @@ public final class TrainOps {
    * @param gradient A tensor of the gradient to be accumulated.
    * @return a new instance of AccumulatorApplyGradient
    */
-  public <T extends Tensor> AccumulatorApplyGradient accumulatorApplyGradient(
+  public <T extends TType> AccumulatorApplyGradient accumulatorApplyGradient(
       Operand<TString> handle, Operand<TInt64> localStep, Operand<T> gradient) {
     return AccumulatorApplyGradient.create(scope, handle, localStep, gradient);
   }
@@ -158,7 +158,7 @@ public AccumulatorSetGlobalStep accumulatorSetGlobalStep(Operand<TString> handle
    *  of the accumulator.
    * @return a new instance of AccumulatorTakeGradient
    */
-  public <T extends Tensor> AccumulatorTakeGradient<T> accumulatorTakeGradient(
+  public <T extends TType> AccumulatorTakeGradient<T> accumulatorTakeGradient(
       Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     return AccumulatorTakeGradient.create(scope, handle, numRequired, dtype);
   }
@@ -182,7 +182,7 @@ public <T extends Tensor> AccumulatorTakeGradient<T> accumulatorTakeGradient(
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdadelta
    */
-  public <T extends Tensor> ApplyAdadelta<T> applyAdadelta(Operand<T> var, Operand<T> accum,
+  public <T extends TType> ApplyAdadelta<T> applyAdadelta(Operand<T> var, Operand<T> accum,
       Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad,
       ApplyAdadelta.Options... options) {
     return ApplyAdadelta.create(scope, var, accum, accumUpdate, lr, rho, epsilon, grad, options);
@@ -202,7 +202,7 @@ public <T extends Tensor> ApplyAdadelta<T> applyAdadelta(Operand<T> var, Operand
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdagrad
    */
-  public <T extends Tensor> ApplyAdagrad<T> applyAdagrad(Operand<T> var, Operand<T> accum,
+  public <T extends TType> ApplyAdagrad<T> applyAdagrad(Operand<T> var, Operand<T> accum,
       Operand<T> lr, Operand<T> grad, ApplyAdagrad.Options... options) {
     return ApplyAdagrad.create(scope, var, accum, lr, grad, options);
   }
@@ -222,7 +222,7 @@ public <T extends Tensor> ApplyAdagrad<T> applyAdagrad(Operand<T> var, Operand<T
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdagradDa
    */
-  public <T extends Tensor> ApplyAdagradDa<T> applyAdagradDa(Operand<T> var,
+  public <T extends TType> ApplyAdagradDa<T> applyAdagradDa(Operand<T> var,
       Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad,
       Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep,
       ApplyAdagradDa.Options... options) {
@@ -251,7 +251,7 @@ public <T extends Tensor> ApplyAdagradDa<T> applyAdagradDa(Operand<T> var,
    * @param options carries optional attributes values
    * @return a new instance of ApplyAdam
    */
-  public <T extends Tensor> ApplyAdam<T> applyAdam(Operand<T> var, Operand<T> m, Operand<T> v,
+  public <T extends TType> ApplyAdam<T> applyAdam(Operand<T> var, Operand<T> m, Operand<T> v,
       Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1,
       Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, ApplyAdam.Options... options) {
     return ApplyAdam.create(scope, var, m, v, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, options);
@@ -275,8 +275,8 @@ public <T extends Tensor> ApplyAdam<T> applyAdam(Operand<T> var, Operand<T> m, O
    * @param options carries optional attributes values
    * @return a new instance of ApplyAddSign
    */
-  public <T extends Tensor> ApplyAddSign<T> applyAddSign(Operand<T> var, Operand<T> m,
-      Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
+  public <T extends TType> ApplyAddSign<T> applyAddSign(Operand<T> var, Operand<T> m, Operand<T> lr,
+      Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
       ApplyAddSign.Options... options) {
     return ApplyAddSign.create(scope, var, m, lr, alpha, signDecay, beta, grad, options);
   }
@@ -316,7 +316,7 @@ public <T extends Tensor> ApplyAddSign<T> applyAddSign(Operand<T> var, Operand<T
    * @param options carries optional attributes values
    * @return a new instance of ApplyCenteredRmsProp
    */
-  public <T extends Tensor> ApplyCenteredRmsProp<T> applyCenteredRmsProp(Operand<T> var,
+  public <T extends TType> ApplyCenteredRmsProp<T> applyCenteredRmsProp(Operand<T> var,
       Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad,
       ApplyCenteredRmsProp.Options... options) {
@@ -347,7 +347,7 @@ public <T extends Tensor> ApplyCenteredRmsProp<T> applyCenteredRmsProp(Operand<T
    * @param options carries optional attributes values
    * @return a new instance of ApplyFtrl
    */
-  public <T extends Tensor> ApplyFtrl<T> applyFtrl(Operand<T> var, Operand<T> accum,
+  public <T extends TType> ApplyFtrl<T> applyFtrl(Operand<T> var, Operand<T> accum,
       Operand<T> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> l2Shrinkage, Operand<T> lrPower, ApplyFtrl.Options... options) {
     return ApplyFtrl.create(scope, var, accum, linear, grad, lr, l1, l2, l2Shrinkage, lrPower, options);
@@ -363,7 +363,7 @@ public <T extends Tensor> ApplyFtrl<T> applyFtrl(Operand<T> var, Operand<T> accu
    * @param options carries optional attributes values
    * @return a new instance of ApplyGradientDescent
    */
-  public <T extends Tensor> ApplyGradientDescent<T> applyGradientDescent(Operand<T> var,
+  public <T extends TType> ApplyGradientDescent<T> applyGradientDescent(Operand<T> var,
       Operand<T> alpha, Operand<T> delta, ApplyGradientDescent.Options... options) {
     return ApplyGradientDescent.create(scope, var, alpha, delta, options);
   }
@@ -385,7 +385,7 @@ public <T extends Tensor> ApplyGradientDescent<T> applyGradientDescent(Operand<T
    * @param options carries optional attributes values
    * @return a new instance of ApplyMomentum
    */
-  public <T extends Tensor> ApplyMomentum<T> applyMomentum(Operand<T> var, Operand<T> accum,
+  public <T extends TType> ApplyMomentum<T> applyMomentum(Operand<T> var, Operand<T> accum,
       Operand<T> lr, Operand<T> grad, Operand<T> momentum, ApplyMomentum.Options... options) {
     return ApplyMomentum.create(scope, var, accum, lr, grad, momentum, options);
   }
@@ -408,7 +408,7 @@ public <T extends Tensor> ApplyMomentum<T> applyMomentum(Operand<T> var, Operand
    * @param options carries optional attributes values
    * @return a new instance of ApplyPowerSign
    */
-  public <T extends Tensor> ApplyPowerSign<T> applyPowerSign(Operand<T> var, Operand<T> m,
+  public <T extends TType> ApplyPowerSign<T> applyPowerSign(Operand<T> var, Operand<T> m,
       Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
       ApplyPowerSign.Options... options) {
     return ApplyPowerSign.create(scope, var, m, lr, logbase, signDecay, beta, grad, options);
@@ -431,7 +431,7 @@ public <T extends Tensor> ApplyPowerSign<T> applyPowerSign(Operand<T> var, Opera
    * @param options carries optional attributes values
    * @return a new instance of ApplyProximalAdagrad
    */
-  public <T extends Tensor> ApplyProximalAdagrad<T> applyProximalAdagrad(Operand<T> var,
+  public <T extends TType> ApplyProximalAdagrad<T> applyProximalAdagrad(Operand<T> var,
       Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad,
       ApplyProximalAdagrad.Options... options) {
     return ApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, options);
@@ -452,7 +452,7 @@ public <T extends Tensor> ApplyProximalAdagrad<T> applyProximalAdagrad(Operand<T
    * @param options carries optional attributes values
    * @return a new instance of ApplyProximalGradientDescent
    */
-  public <T extends Tensor> ApplyProximalGradientDescent<T> applyProximalGradientDescent(
+  public <T extends TType> ApplyProximalGradientDescent<T> applyProximalGradientDescent(
       Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta,
       ApplyProximalGradientDescent.Options... options) {
     return ApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, delta, options);
@@ -484,7 +484,7 @@ public <T extends Tensor> ApplyProximalGradientDescent<T> applyProximalGradientD
    * @param options carries optional attributes values
    * @return a new instance of ApplyRmsProp
    */
-  public <T extends Tensor> ApplyRmsProp<T> applyRmsProp(Operand<T> var, Operand<T> ms,
+  public <T extends TType> ApplyRmsProp<T> applyRmsProp(Operand<T> var, Operand<T> ms,
       Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon,
       Operand<T> grad, ApplyRmsProp.Options... options) {
     return ApplyRmsProp.create(scope, var, ms, mom, lr, rho, momentum, epsilon, grad, options);
@@ -522,7 +522,7 @@ public <T extends Tensor> ApplyRmsProp<T> applyRmsProp(Operand<T> var, Operand<T
    * @param options carries optional attributes values
    * @return a new instance of BatchMatMul
    */
-  public <T extends Tensor> BatchMatMul<T> batchMatMul(Operand<T> x, Operand<T> y,
+  public <T extends TType> BatchMatMul<T> batchMatMul(Operand<T> x, Operand<T> y,
       BatchMatMul.Options... options) {
     return BatchMatMul.create(scope, x, y, options);
   }
@@ -542,7 +542,7 @@ public <T extends Tensor> BatchMatMul<T> batchMatMul(Operand<T> x, Operand<T> y,
    * @param options carries optional attributes values
    * @return a new instance of ConditionalAccumulator
    */
-  public <T extends Tensor> ConditionalAccumulator conditionalAccumulator(DataType<T> dtype,
+  public <T extends TType> ConditionalAccumulator conditionalAccumulator(DataType<T> dtype,
       Shape shape, ConditionalAccumulator.Options... options) {
     return ConditionalAccumulator.create(scope, dtype, shape, options);
   }
@@ -649,7 +649,7 @@ public NegTrain negTrain(Operand<TFloat32> wIn, Operand<TFloat32> wOut, Operand<
    * @param options carries optional attributes values
    * @return a new instance of PreventGradient
    */
-  public <T extends Tensor> PreventGradient<T> preventGradient(Operand<T> input,
+  public <T extends TType> PreventGradient<T> preventGradient(Operand<T> input,
       PreventGradient.Options... options) {
     return PreventGradient.create(scope, input, options);
   }
@@ -672,7 +672,7 @@ public <T extends Tensor> PreventGradient<T> preventGradient(Operand<T> input,
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdadelta
    */
-  public <T extends Tensor> ResourceApplyAdadelta resourceApplyAdadelta(Operand<?> var,
+  public <T extends TType> ResourceApplyAdadelta resourceApplyAdadelta(Operand<?> var,
       Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon,
       Operand<T> grad, ResourceApplyAdadelta.Options... options) {
     return ResourceApplyAdadelta.create(scope, var, accum, accumUpdate, lr, rho, epsilon, grad, options);
@@ -692,7 +692,7 @@ public <T extends Tensor> ResourceApplyAdadelta resourceApplyAdadelta(Operand<?>
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdagradDa
    */
-  public <T extends Tensor> ResourceApplyAdagradDa resourceApplyAdagradDa(Operand<?> var,
+  public <T extends TType> ResourceApplyAdagradDa resourceApplyAdagradDa(Operand<?> var,
       Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad,
       Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep,
       ResourceApplyAdagradDa.Options... options) {
@@ -720,7 +720,7 @@ public <T extends Tensor> ResourceApplyAdagradDa resourceApplyAdagradDa(Operand<
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdam
    */
-  public <T extends Tensor> ResourceApplyAdam resourceApplyAdam(Operand<?> var, Operand<?> m,
+  public <T extends TType> ResourceApplyAdam resourceApplyAdam(Operand<?> var, Operand<?> m,
       Operand<?> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1,
       Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, ResourceApplyAdam.Options... options) {
     return ResourceApplyAdam.create(scope, var, m, v, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, options);
@@ -749,10 +749,10 @@ public <T extends Tensor> ResourceApplyAdam resourceApplyAdam(Operand<?> var, Op
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAdamWithAmsgrad
    */
-  public <T extends Tensor> ResourceApplyAdamWithAmsgrad resourceApplyAdamWithAmsgrad(
-      Operand<?> var, Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power,
-      Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon,
-      Operand<T> grad, ResourceApplyAdamWithAmsgrad.Options... options) {
+  public <T extends TType> ResourceApplyAdamWithAmsgrad resourceApplyAdamWithAmsgrad(Operand<?> var,
+      Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power, Operand<T> beta2Power,
+      Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad,
+      ResourceApplyAdamWithAmsgrad.Options... options) {
     return ResourceApplyAdamWithAmsgrad.create(scope, var, m, v, vhat, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, options);
   }
 
@@ -773,7 +773,7 @@ public <T extends Tensor> ResourceApplyAdamWithAmsgrad resourceApplyAdamWithAmsg
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyAddSign
    */
-  public <T extends Tensor> ResourceApplyAddSign resourceApplyAddSign(Operand<?> var, Operand<?> m,
+  public <T extends TType> ResourceApplyAddSign resourceApplyAddSign(Operand<?> var, Operand<?> m,
       Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad,
       ResourceApplyAddSign.Options... options) {
     return ResourceApplyAddSign.create(scope, var, m, lr, alpha, signDecay, beta, grad, options);
@@ -813,8 +813,8 @@ public <T extends Tensor> ResourceApplyAddSign resourceApplyAddSign(Operand<?> v
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyCenteredRmsProp
    */
-  public <T extends Tensor> ResourceApplyCenteredRmsProp resourceApplyCenteredRmsProp(
-      Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
+  public <T extends TType> ResourceApplyCenteredRmsProp resourceApplyCenteredRmsProp(Operand<?> var,
+      Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad,
       ResourceApplyCenteredRmsProp.Options... options) {
     return ResourceApplyCenteredRmsProp.create(scope, var, mg, ms, mom, lr, rho, momentum, epsilon, grad, options);
@@ -843,7 +843,7 @@ public <T extends Tensor> ResourceApplyCenteredRmsProp resourceApplyCenteredRmsP
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyFtrl
    */
-  public <T extends Tensor> ResourceApplyFtrl resourceApplyFtrl(Operand<?> var, Operand<?> accum,
+  public <T extends TType> ResourceApplyFtrl resourceApplyFtrl(Operand<?> var, Operand<?> accum,
       Operand<?> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> l2Shrinkage, Operand<T> lrPower, ResourceApplyFtrl.Options... options) {
     return ResourceApplyFtrl.create(scope, var, accum, linear, grad, lr, l1, l2, l2Shrinkage, lrPower, options);
@@ -858,9 +858,8 @@ public <T extends Tensor> ResourceApplyFtrl resourceApplyFtrl(Operand<?> var, Op
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyGradientDescent
    */
-  public <T extends Tensor> ResourceApplyGradientDescent resourceApplyGradientDescent(
-      Operand<?> var, Operand<T> alpha, Operand<T> delta,
-      ResourceApplyGradientDescent.Options... options) {
+  public <T extends TType> ResourceApplyGradientDescent resourceApplyGradientDescent(Operand<?> var,
+      Operand<T> alpha, Operand<T> delta, ResourceApplyGradientDescent.Options... options) {
     return ResourceApplyGradientDescent.create(scope, var, alpha, delta, options);
   }
 
@@ -880,7 +879,7 @@ public <T extends Tensor> ResourceApplyGradientDescent resourceApplyGradientDesc
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyKerasMomentum
    */
-  public <T extends Tensor> ResourceApplyKerasMomentum resourceApplyKerasMomentum(Operand<?> var,
+  public <T extends TType> ResourceApplyKerasMomentum resourceApplyKerasMomentum(Operand<?> var,
       Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum,
       ResourceApplyKerasMomentum.Options... options) {
     return ResourceApplyKerasMomentum.create(scope, var, accum, lr, grad, momentum, options);
@@ -902,7 +901,7 @@ public <T extends Tensor> ResourceApplyKerasMomentum resourceApplyKerasMomentum(
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyMomentum
    */
-  public <T extends Tensor> ResourceApplyMomentum resourceApplyMomentum(Operand<?> var,
+  public <T extends TType> ResourceApplyMomentum resourceApplyMomentum(Operand<?> var,
       Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum,
       ResourceApplyMomentum.Options... options) {
     return ResourceApplyMomentum.create(scope, var, accum, lr, grad, momentum, options);
@@ -925,7 +924,7 @@ public <T extends Tensor> ResourceApplyMomentum resourceApplyMomentum(Operand<?>
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyPowerSign
    */
-  public <T extends Tensor> ResourceApplyPowerSign resourceApplyPowerSign(Operand<?> var,
+  public <T extends TType> ResourceApplyPowerSign resourceApplyPowerSign(Operand<?> var,
       Operand<?> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta,
       Operand<T> grad, ResourceApplyPowerSign.Options... options) {
     return ResourceApplyPowerSign.create(scope, var, m, lr, logbase, signDecay, beta, grad, options);
@@ -947,9 +946,9 @@ public <T extends Tensor> ResourceApplyPowerSign resourceApplyPowerSign(Operand<
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyProximalAdagrad
    */
-  public <T extends Tensor> ResourceApplyProximalAdagrad resourceApplyProximalAdagrad(
-      Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2,
-      Operand<T> grad, ResourceApplyProximalAdagrad.Options... options) {
+  public <T extends TType> ResourceApplyProximalAdagrad resourceApplyProximalAdagrad(Operand<?> var,
+      Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad,
+      ResourceApplyProximalAdagrad.Options... options) {
     return ResourceApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, options);
   }
 
@@ -967,7 +966,7 @@ public <T extends Tensor> ResourceApplyProximalAdagrad resourceApplyProximalAdag
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyProximalGradientDescent
    */
-  public <T extends Tensor> ResourceApplyProximalGradientDescent resourceApplyProximalGradientDescent(
+  public <T extends TType> ResourceApplyProximalGradientDescent resourceApplyProximalGradientDescent(
       Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta,
       ResourceApplyProximalGradientDescent.Options... options) {
     return ResourceApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, delta, options);
@@ -998,7 +997,7 @@ public <T extends Tensor> ResourceApplyProximalGradientDescent resourceApplyProx
    * @param options carries optional attributes values
    * @return a new instance of ResourceApplyRmsProp
    */
-  public <T extends Tensor> ResourceApplyRmsProp resourceApplyRmsProp(Operand<?> var, Operand<?> ms,
+  public <T extends TType> ResourceApplyRmsProp resourceApplyRmsProp(Operand<?> var, Operand<?> ms,
       Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon,
       Operand<T> grad, ResourceApplyRmsProp.Options... options) {
     return ResourceApplyRmsProp.create(scope, var, ms, mom, lr, rho, momentum, epsilon, grad, options);
@@ -1018,7 +1017,7 @@ public <T extends Tensor> ResourceApplyRmsProp resourceApplyRmsProp(Operand<?> v
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyAdadelta
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdadelta resourceSparseApplyAdadelta(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyAdadelta resourceSparseApplyAdadelta(
       Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho,
       Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyAdadelta.Options... options) {
@@ -1040,7 +1039,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdadelt
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyAdagrad
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagrad resourceSparseApplyAdagrad(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyAdagrad resourceSparseApplyAdagrad(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyAdagrad.Options... options) {
     return ResourceSparseApplyAdagrad.create(scope, var, accum, lr, grad, indices, options);
@@ -1061,7 +1060,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagrad
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyAdagradDa
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagradDa resourceSparseApplyAdagradDa(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyAdagradDa resourceSparseApplyAdagradDa(
       Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator,
       Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<TInt64> globalStep, ResourceSparseApplyAdagradDa.Options... options) {
@@ -1101,7 +1100,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagrad
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyCenteredRmsProp
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyCenteredRmsProp resourceSparseApplyCenteredRmsProp(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyCenteredRmsProp resourceSparseApplyCenteredRmsProp(
       Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyCenteredRmsProp.Options... options) {
@@ -1133,7 +1132,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyCentere
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyFtrl
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyFtrl resourceSparseApplyFtrl(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyFtrl resourceSparseApplyFtrl(
       Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<U> indices,
       Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower,
       ResourceSparseApplyFtrl.Options... options) {
@@ -1159,7 +1158,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyFtrl re
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyKerasMomentum
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyKerasMomentum resourceSparseApplyKerasMomentum(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyKerasMomentum resourceSparseApplyKerasMomentum(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       Operand<T> momentum, ResourceSparseApplyKerasMomentum.Options... options) {
     return ResourceSparseApplyKerasMomentum.create(scope, var, accum, lr, grad, indices, momentum, options);
@@ -1184,7 +1183,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyKerasMo
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyMomentum
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyMomentum resourceSparseApplyMomentum(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyMomentum resourceSparseApplyMomentum(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       Operand<T> momentum, ResourceSparseApplyMomentum.Options... options) {
     return ResourceSparseApplyMomentum.create(scope, var, accum, lr, grad, indices, momentum, options);
@@ -1209,7 +1208,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyMomentu
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyProximalAdagrad
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalAdagrad resourceSparseApplyProximalAdagrad(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyProximalAdagrad resourceSparseApplyProximalAdagrad(
       Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> grad, Operand<U> indices, ResourceSparseApplyProximalAdagrad.Options... options) {
     return ResourceSparseApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, indices, options);
@@ -1231,7 +1230,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProxima
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyProximalGradientDescent
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalGradientDescent resourceSparseApplyProximalGradientDescent(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyProximalGradientDescent resourceSparseApplyProximalGradientDescent(
       Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad,
       Operand<U> indices, ResourceSparseApplyProximalGradientDescent.Options... options) {
     return ResourceSparseApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, grad, indices, options);
@@ -1263,7 +1262,7 @@ public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProxima
    * @param options carries optional attributes values
    * @return a new instance of ResourceSparseApplyRmsProp
    */
-  public <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyRmsProp resourceSparseApplyRmsProp(
+  public <T extends TType, U extends TNumber> ResourceSparseApplyRmsProp resourceSparseApplyRmsProp(
       Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       ResourceSparseApplyRmsProp.Options... options) {
@@ -1321,7 +1320,7 @@ public Restore restore(Operand<TString> prefix, Operand<TString> tensorNames,
    * @param options carries optional attributes values
    * @return a new instance of RestoreSlice
    */
-  public <T extends Tensor> RestoreSlice<T> restoreSlice(Operand<TString> filePattern,
+  public <T extends TType> RestoreSlice<T> restoreSlice(Operand<TString> filePattern,
       Operand<TString> tensorName, Operand<TString> shapeAndSlice, DataType<T> dt,
       RestoreSlice.Options... options) {
     return RestoreSlice.create(scope, filePattern, tensorName, shapeAndSlice, dt, options);
@@ -1431,7 +1430,7 @@ public SdcaShrinkL1 sdcaShrinkL1(Iterable<Operand<TFloat32>> weights, Float l1,
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyAdadelta
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdadelta<T> sparseApplyAdadelta(
+  public <T extends TType, U extends TNumber> SparseApplyAdadelta<T> sparseApplyAdadelta(
       Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho,
       Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       SparseApplyAdadelta.Options... options) {
@@ -1454,7 +1453,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdadelta<T> spa
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyAdagradDa
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdagradDa<T> sparseApplyAdagradDa(
+  public <T extends TType, U extends TNumber> SparseApplyAdagradDa<T> sparseApplyAdagradDa(
       Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator,
       Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<TInt64> globalStep, SparseApplyAdagradDa.Options... options) {
@@ -1495,7 +1494,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdagradDa<T> sp
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyCenteredRmsProp
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyCenteredRmsProp<T> sparseApplyCenteredRmsProp(
+  public <T extends TType, U extends TNumber> SparseApplyCenteredRmsProp<T> sparseApplyCenteredRmsProp(
       Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       SparseApplyCenteredRmsProp.Options... options) {
@@ -1528,9 +1527,9 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyCenteredRmsProp
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyFtrl
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyFtrl<T> sparseApplyFtrl(
-      Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices,
-      Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower,
+  public <T extends TType, U extends TNumber> SparseApplyFtrl<T> sparseApplyFtrl(Operand<T> var,
+      Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr,
+      Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower,
       SparseApplyFtrl.Options... options) {
     return SparseApplyFtrl.create(scope, var, accum, linear, grad, indices, lr, l1, l2, l2Shrinkage, lrPower, options);
   }
@@ -1555,7 +1554,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyFtrl<T> sparseA
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyMomentum
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyMomentum<T> sparseApplyMomentum(
+  public <T extends TType, U extends TNumber> SparseApplyMomentum<T> sparseApplyMomentum(
       Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices,
       Operand<T> momentum, SparseApplyMomentum.Options... options) {
     return SparseApplyMomentum.create(scope, var, accum, lr, grad, indices, momentum, options);
@@ -1581,7 +1580,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyMomentum<T> spa
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyProximalAdagrad
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalAdagrad<T> sparseApplyProximalAdagrad(
+  public <T extends TType, U extends TNumber> SparseApplyProximalAdagrad<T> sparseApplyProximalAdagrad(
       Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2,
       Operand<T> grad, Operand<U> indices, SparseApplyProximalAdagrad.Options... options) {
     return SparseApplyProximalAdagrad.create(scope, var, accum, lr, l1, l2, grad, indices, options);
@@ -1604,7 +1603,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalAdagrad
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyProximalGradientDescent
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalGradientDescent<T> sparseApplyProximalGradientDescent(
+  public <T extends TType, U extends TNumber> SparseApplyProximalGradientDescent<T> sparseApplyProximalGradientDescent(
       Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad,
       Operand<U> indices, SparseApplyProximalGradientDescent.Options... options) {
     return SparseApplyProximalGradientDescent.create(scope, var, alpha, l1, l2, grad, indices, options);
@@ -1637,7 +1636,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalGradien
    * @param options carries optional attributes values
    * @return a new instance of SparseApplyRmsProp
    */
-  public <T extends Tensor, U extends Tensor & TNumber> SparseApplyRmsProp<T> sparseApplyRmsProp(
+  public <T extends TType, U extends TNumber> SparseApplyRmsProp<T> sparseApplyRmsProp(
       Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho,
       Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices,
       SparseApplyRmsProp.Options... options) {
@@ -1656,7 +1655,7 @@ public <T extends Tensor, U extends Tensor & TNumber> SparseApplyRmsProp<T> spar
    * @param multiples
    * @return a new instance of TileGrad
    */
-  public <T extends Tensor> TileGrad<T> tileGrad(Operand<T> input, Operand<TInt32> multiples) {
+  public <T extends TType> TileGrad<T> tileGrad(Operand<T> input, Operand<TInt32> multiples) {
     return TileGrad.create(scope, input, multiples);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java
index 01d4ffa1ba7..535972d4883 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java
@@ -19,7 +19,6 @@
 
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.xla.BroadcastHelper;
 import org.tensorflow.op.xla.ClusterOutput;
@@ -40,6 +39,7 @@
 import org.tensorflow.op.xla.Sort;
 import org.tensorflow.op.xla.Svd;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An API for building {@code xla} operations as {@link Op Op}s
@@ -66,8 +66,8 @@ public final class XlaOps {
    * @param broadcastDims an XLA-style broadcast dimension specification
    * @return a new instance of BroadcastHelper
    */
-  public <T extends Tensor, U extends Tensor & TNumber> BroadcastHelper<T> broadcastHelper(
-      Operand<T> lhs, Operand<T> rhs, Operand<U> broadcastDims) {
+  public <T extends TType, U extends TNumber> BroadcastHelper<T> broadcastHelper(Operand<T> lhs,
+      Operand<T> rhs, Operand<U> broadcastDims) {
     return BroadcastHelper.create(scope, lhs, rhs, broadcastDims);
   }
 
@@ -78,7 +78,7 @@ public <T extends Tensor, U extends Tensor & TNumber> BroadcastHelper<T> broadca
    * @param input
    * @return a new instance of ClusterOutput
    */
-  public <T extends Tensor> ClusterOutput<T> clusterOutput(Operand<T> input) {
+  public <T extends TType> ClusterOutput<T> clusterOutput(Operand<T> input) {
     return ClusterOutput.create(scope, input);
   }
 
@@ -100,7 +100,7 @@ public <T extends Tensor> ClusterOutput<T> clusterOutput(Operand<T> input) {
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
    * @return a new instance of Conv
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Conv<T> conv(Operand<T> lhs, Operand<T> rhs,
+  public <T extends TType, U extends TNumber> Conv<T> conv(Operand<T> lhs, Operand<T> rhs,
       Operand<U> windowStrides, Operand<U> padding, Operand<U> lhsDilation, Operand<U> rhsDilation,
       Operand<U> featureGroupCount, String dimensionNumbers, String precisionConfig) {
     return Conv.create(scope, lhs, rhs, windowStrides, padding, lhsDilation, rhsDilation, featureGroupCount, dimensionNumbers, precisionConfig);
@@ -137,7 +137,7 @@ public Dequantize dequantize(Operand<?> input, Float minRange, Float maxRange, S
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
    * @return a new instance of Dot
    */
-  public <T extends Tensor> Dot<T> dot(Operand<T> lhs, Operand<T> rhs, String dimensionNumbers,
+  public <T extends TType> Dot<T> dot(Operand<T> lhs, Operand<T> rhs, String dimensionNumbers,
       String precisionConfig) {
     return Dot.create(scope, lhs, rhs, dimensionNumbers, precisionConfig);
   }
@@ -163,8 +163,8 @@ public <T extends Tensor> Dot<T> dot(Operand<T> lhs, Operand<T> rhs, String dime
    * @param sizeIndices
    * @return a new instance of DynamicSlice
    */
-  public <T extends Tensor, U extends Tensor & TNumber> DynamicSlice<T> dynamicSlice(
-      Operand<T> input, Operand<U> startIndices, Operand<U> sizeIndices) {
+  public <T extends TType, U extends TNumber> DynamicSlice<T> dynamicSlice(Operand<T> input,
+      Operand<U> startIndices, Operand<U> sizeIndices) {
     return DynamicSlice.create(scope, input, startIndices, sizeIndices);
   }
 
@@ -188,7 +188,7 @@ public <T extends Tensor, U extends Tensor & TNumber> DynamicSlice<T> dynamicSli
    *  `input`.
    * @return a new instance of DynamicUpdateSlice
    */
-  public <T extends Tensor, U extends Tensor & TNumber> DynamicUpdateSlice<T> dynamicUpdateSlice(
+  public <T extends TType, U extends TNumber> DynamicUpdateSlice<T> dynamicUpdateSlice(
       Operand<T> input, Operand<T> update, Operand<U> indices) {
     return DynamicUpdateSlice.create(scope, input, update, indices);
   }
@@ -205,7 +205,7 @@ public <T extends Tensor, U extends Tensor & TNumber> DynamicUpdateSlice<T> dyna
    * @param equation
    * @return a new instance of Einsum
    */
-  public <T extends Tensor> Einsum<T> einsum(Operand<T> a, Operand<T> b, String equation) {
+  public <T extends TType> Einsum<T> einsum(Operand<T> a, Operand<T> b, String equation) {
     return Einsum.create(scope, a, b, equation);
   }
 
@@ -222,7 +222,7 @@ public <T extends Tensor> Einsum<T> einsum(Operand<T> a, Operand<T> b, String eq
    * @param indicesAreSorted Boolean indicating if the indices are sorted.
    * @return a new instance of Gather
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Gather<T> gather(Operand<T> operand,
+  public <T extends TType, U extends TNumber> Gather<T> gather(Operand<T> operand,
       Operand<U> startIndices, Operand<U> sliceSizes, String dimensionNumbers,
       Boolean indicesAreSorted) {
     return Gather.create(scope, operand, startIndices, sliceSizes, dimensionNumbers, indicesAreSorted);
@@ -242,8 +242,8 @@ public <T extends Tensor, U extends Tensor & TNumber> Gather<T> gather(Operand<T
    * @param values A `Tensor` of type V.
    * @return a new instance of KeyValueSort
    */
-  public <T extends Tensor & TNumber, U extends Tensor> KeyValueSort<T, U> keyValueSort(
-      Operand<T> keys, Operand<U> values) {
+  public <T extends TNumber, U extends TType> KeyValueSort<T, U> keyValueSort(Operand<T> keys,
+      Operand<U> values) {
     return KeyValueSort.create(scope, keys, values);
   }
 
@@ -261,9 +261,8 @@ public <T extends Tensor & TNumber, U extends Tensor> KeyValueSort<T, U> keyValu
    * @param paddingInterior the padding to apply between each input element.
    * @return a new instance of Pad
    */
-  public <T extends Tensor, U extends Tensor & TNumber> Pad<T> pad(Operand<T> input,
-      Operand<T> paddingValue, Operand<U> paddingLow, Operand<U> paddingHigh,
-      Operand<U> paddingInterior) {
+  public <T extends TType, U extends TNumber> Pad<T> pad(Operand<T> input, Operand<T> paddingValue,
+      Operand<U> paddingLow, Operand<U> paddingHigh, Operand<U> paddingInterior) {
     return Pad.create(scope, input, paddingValue, paddingLow, paddingHigh, paddingInterior);
   }
 
@@ -279,7 +278,7 @@ public <T extends Tensor, U extends Tensor & TNumber> Pad<T> pad(Operand<T> inpu
    * @param shape The shape of the tensor.
    * @return a new instance of Recv
    */
-  public <T extends Tensor> Recv<T> recv(DataType<T> dtype, String tensorName, Shape shape) {
+  public <T extends TType> Recv<T> recv(DataType<T> dtype, String tensorName, Shape shape) {
     return Recv.create(scope, dtype, tensorName, shape);
   }
 
@@ -312,7 +311,7 @@ public ReplicaId replicaId() {
    * @param epsilon the tolerance ratio.
    * @return a new instance of SelfAdjointEig
    */
-  public <T extends Tensor> SelfAdjointEig<T> selfAdjointEig(Operand<T> a, Boolean lower,
+  public <T extends TType> SelfAdjointEig<T> selfAdjointEig(Operand<T> a, Boolean lower,
       Long maxIter, Float epsilon) {
     return SelfAdjointEig.create(scope, a, lower, maxIter, epsilon);
   }
@@ -327,7 +326,7 @@ public <T extends Tensor> SelfAdjointEig<T> selfAdjointEig(Operand<T> a, Boolean
    * @param tensorName A string key that identifies the channel.
    * @return a new instance of Send
    */
-  public <T extends Tensor> Send send(Operand<T> tensor, String tensorName) {
+  public <T extends TType> Send send(Operand<T> tensor, String tensorName) {
     return Send.create(scope, tensor, tensorName);
   }
 
@@ -338,7 +337,7 @@ public <T extends Tensor> Send send(Operand<T> tensor, String tensorName) {
    * @param input
    * @return a new instance of Sharding
    */
-  public <T extends Tensor> Sharding<T> sharding(Operand<T> input) {
+  public <T extends TType> Sharding<T> sharding(Operand<T> input) {
     return Sharding.create(scope, input);
   }
 
@@ -354,7 +353,7 @@ public <T extends Tensor> Sharding<T> sharding(Operand<T> input) {
    * @param input A `Tensor` of type T.
    * @return a new instance of Sort
    */
-  public <T extends Tensor> Sort<T> sort(Operand<T> input) {
+  public <T extends TType> Sort<T> sort(Operand<T> input) {
     return Sort.create(scope, input);
   }
 
@@ -376,7 +375,7 @@ public <T extends Tensor> Sort<T> sort(Operand<T> input) {
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
    * @return a new instance of Svd
    */
-  public <T extends Tensor> Svd<T> svd(Operand<T> a, Long maxIter, Float epsilon,
+  public <T extends TType> Svd<T> svd(Operand<T> a, Long maxIter, Float epsilon,
       String precisionConfig) {
     return Svd.create(scope, a, maxIter, epsilon, precisionConfig);
   }
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 6774323de4d..232f24bdc0d 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
@@ -93,7 +93,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static AudioSpectrogram create(Scope scope, Operand<TFloat32> input, Long windowSize, Long stride, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AudioSpectrogram", scope.makeOpName("AudioSpectrogram"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("window_size", windowSize);
     opBuilder.setAttr("stride", stride);
@@ -123,7 +123,7 @@ public Output<TFloat32> spectrogram() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return spectrogram;
   }
   
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 a58d814660c..7a38b5b4dc2 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
@@ -89,7 +89,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DecodeWav create(Scope scope, Operand<TString> contents, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeWav", scope.makeOpName("DecodeWav"));
-    opBuilder.addInput(contents.asOutput());
+    opBuilder.addInput(contents.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 2336a3124c5..d6d54ba7faa 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
@@ -54,8 +54,8 @@ public final class EncodeWav extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static EncodeWav create(Scope scope, Operand<TFloat32> audio, Operand<TInt32> sampleRate) {
     OperationBuilder opBuilder = scope.env().opBuilder("EncodeWav", scope.makeOpName("EncodeWav"));
-    opBuilder.addInput(audio.asOutput());
-    opBuilder.addInput(sampleRate.asOutput());
+    opBuilder.addInput(audio.asOutput(scope));
+    opBuilder.addInput(sampleRate.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new EncodeWav(opBuilder.build());
   }
@@ -68,7 +68,7 @@ public Output<TString> contents() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return contents;
   }
   
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 a13d22fdb4a..f89f6858d07 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
@@ -102,8 +102,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Mfcc create(Scope scope, Operand<TFloat32> spectrogram, Operand<TInt32> sampleRate, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Mfcc", scope.makeOpName("Mfcc"));
-    opBuilder.addInput(spectrogram.asOutput());
-    opBuilder.addInput(sampleRate.asOutput());
+    opBuilder.addInput(spectrogram.asOutput(scope));
+    opBuilder.addInput(sampleRate.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -161,7 +161,7 @@ public Output<TFloat32> output() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return output;
   }
   
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 b77f54e56ea..a5edf08f11c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,7 +53,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseAnd<T extends Tensor & TNumber> extends RawOp 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.
@@ -65,10 +64,10 @@ public final class BitwiseAnd<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of BitwiseAnd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BitwiseAnd<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> BitwiseAnd<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("BitwiseAnd", scope.makeOpName("BitwiseAnd"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BitwiseAnd<T>(opBuilder.build());
   }
@@ -80,7 +79,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 ddcc206c9da..1f98acc6f31 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,7 +53,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseOr<T extends Tensor & TNumber> extends RawOp 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.
@@ -65,10 +64,10 @@ public final class BitwiseOr<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of BitwiseOr
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BitwiseOr<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> BitwiseOr<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("BitwiseOr", scope.makeOpName("BitwiseOr"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BitwiseOr<T>(opBuilder.build());
   }
@@ -80,7 +79,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 272aee6ece8..b2e1c72defc 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,7 +53,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class BitwiseXor<T extends Tensor & TNumber> extends RawOp 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.
@@ -65,10 +64,10 @@ public final class BitwiseXor<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of BitwiseXor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BitwiseXor<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> BitwiseXor<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("BitwiseXor", scope.makeOpName("BitwiseXor"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BitwiseXor<T>(opBuilder.build());
   }
@@ -80,7 +79,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 7c680b4bfdc..6154331c843 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -75,7 +74,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "bitwise")
-public final class Invert<T extends Tensor & TNumber> extends RawOp 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.
@@ -85,9 +84,9 @@ public final class Invert<T extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of Invert
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Invert<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Invert<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Invert", scope.makeOpName("Invert"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Invert<T>(opBuilder.build());
   }
@@ -99,7 +98,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 b0b9d5bf9ec..2e66c974de3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -65,7 +64,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class LeftShift<T extends Tensor & TNumber> extends RawOp 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.
@@ -76,10 +75,10 @@ public final class LeftShift<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of LeftShift
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LeftShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> LeftShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("LeftShift", scope.makeOpName("LeftShift"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LeftShift<T>(opBuilder.build());
   }
@@ -91,7 +90,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 d9d71249c17..16e97117ecf 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -68,7 +67,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "bitwise")
-public final class RightShift<T extends Tensor & TNumber> extends RawOp 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.
@@ -79,10 +78,10 @@ public final class RightShift<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of RightShift
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> RightShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> RightShift<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("RightShift", scope.makeOpName("RightShift"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RightShift<T>(opBuilder.build());
   }
@@ -94,7 +93,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 350036bbdc6..a872a6f8496 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
@@ -50,8 +50,8 @@ public final class KMC2ChainInitialization extends RawOp implements Operand<TInt
   @Endpoint(describeByClass = true)
   public static KMC2ChainInitialization create(Scope scope, Operand<TFloat32> distances, Operand<TInt64> seed) {
     OperationBuilder opBuilder = scope.env().opBuilder("KMC2ChainInitialization", scope.makeOpName("KMC2ChainInitialization"));
-    opBuilder.addInput(distances.asOutput());
-    opBuilder.addInput(seed.asOutput());
+    opBuilder.addInput(distances.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new KMC2ChainInitialization(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<TInt64> index() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return index;
   }
   
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 a8d6f3eb70b..a26bb5432bd 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
@@ -54,10 +54,10 @@ public final class KmeansPlusPlusInitialization extends RawOp implements Operand
   @Endpoint(describeByClass = true)
   public static KmeansPlusPlusInitialization create(Scope scope, Operand<TFloat32> points, Operand<TInt64> numToSample, Operand<TInt64> seed, Operand<TInt64> numRetriesPerSample) {
     OperationBuilder opBuilder = scope.env().opBuilder("KmeansPlusPlusInitialization", scope.makeOpName("KmeansPlusPlusInitialization"));
-    opBuilder.addInput(points.asOutput());
-    opBuilder.addInput(numToSample.asOutput());
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(numRetriesPerSample.asOutput());
+    opBuilder.addInput(points.asOutput(scope));
+    opBuilder.addInput(numToSample.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(numRetriesPerSample.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new KmeansPlusPlusInitialization(opBuilder.build());
   }
@@ -70,7 +70,7 @@ public Output<TFloat32> samples() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return samples;
   }
   
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 36802bca597..9318b8df55f 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AllReduce<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class AllReduce<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.AllReduce}
@@ -79,9 +78,9 @@ private Options() {
    * @return a new instance of AllReduce
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AllReduce<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, String mergeOp, String finalOp, List<Long> subdivOffsets, Options... options) {
+  public static <T extends TNumber> AllReduce<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, String mergeOp, String finalOp, List<Long> subdivOffsets, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveReduce", scope.makeOpName("AllReduce"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("group_size", groupSize);
     opBuilder.setAttr("group_key", groupKey);
@@ -131,7 +130,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 02c3aaed8f5..f829cb75210 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Receives a tensor value broadcast from another device.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class BroadcastRecv<T extends Tensor> extends RawOp implements Operand<T> {
+public final class BroadcastRecv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.BroadcastRecv}
@@ -68,7 +68,7 @@ private Options() {
    * @return a new instance of BroadcastRecv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BroadcastRecv<T> create(Scope scope, DataType<T> T, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
+  public static <T extends TType> BroadcastRecv<T> create(Scope scope, DataType<T> T, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveBcastRecv", scope.makeOpName("BroadcastRecv"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("T", T);
@@ -100,7 +100,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 4e6b36d4d9a..ff5905a61db 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Broadcasts a tensor value to one or more other devices.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class BroadcastSend<T extends Tensor> extends RawOp implements Operand<T> {
+public final class BroadcastSend<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.collective.BroadcastSend}
@@ -67,9 +67,9 @@ private Options() {
    * @return a new instance of BroadcastSend
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BroadcastSend<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
+  public static <T extends TType> BroadcastSend<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveBcastSend", scope.makeOpName("BroadcastSend"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("group_size", groupSize);
     opBuilder.setAttr("group_key", groupKey);
@@ -99,7 +99,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 e77f4a0651b..95acd0433a1 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -70,10 +69,10 @@ private Options() {
    * @return a new instance of All
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> All create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends TNumber> All create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("All", scope.makeOpName("All"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +99,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 5acc0247db6..6222b9c50d8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -70,10 +69,10 @@ private Options() {
    * @return a new instance of Any
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Any create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends TNumber> Any create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Any", scope.makeOpName("Any"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +99,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 a56b01c90aa..ca758ea0801 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
@@ -67,8 +67,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static AssertThat create(Scope scope, Operand<TBool> condition, Iterable<Operand<?>> data, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Assert", scope.makeOpName("AssertThat"));
-    opBuilder.addInput(condition.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(data));
+    opBuilder.addInput(condition.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, data));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 1c10f9fc35e..0752ca68a4c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update 'ref' by assigning 'value' to it.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class Assign<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Assign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Assign}
@@ -79,10 +79,10 @@ private Options() {
    * @return a new instance of Assign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Assign<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
+  public static <T extends TType> Assign<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Assign", scope.makeOpName("Assign"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -123,7 +123,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 61a3a287abd..570e8f97ffb 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update 'ref' by adding 'value' to it.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class AssignAdd<T extends Tensor> extends RawOp implements Operand<T> {
+public final class AssignAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.AssignAdd}
@@ -68,10 +68,10 @@ private Options() {
    * @return a new instance of AssignAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AssignAdd<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
+  public static <T extends TType> AssignAdd<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignAdd", scope.makeOpName("AssignAdd"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +100,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 cf3f4c9560c..5249d72ac2a 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds a value to the current value of a variable.
@@ -44,10 +44,10 @@ public final class AssignAddVariableOp extends RawOp {
    * @return a new instance of AssignAddVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AssignAddVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
+  public static <T extends TType> AssignAddVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignAddVariableOp", scope.makeOpName("AssignAddVariableOp"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AssignAddVariableOp(opBuilder.build());
   }
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 defe21e80a6..7268972953c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update 'ref' by subtracting 'value' from it.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class AssignSub<T extends Tensor> extends RawOp implements Operand<T> {
+public final class AssignSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.AssignSub}
@@ -68,10 +68,10 @@ private Options() {
    * @return a new instance of AssignSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AssignSub<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
+  public static <T extends TType> AssignSub<T> create(Scope scope, Operand<T> ref, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignSub", scope.makeOpName("AssignSub"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +100,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 3168e4924ea..1bf0b7cdd13 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts a value from the current value of a variable.
@@ -44,10 +44,10 @@ public final class AssignSubVariableOp extends RawOp {
    * @return a new instance of AssignSubVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AssignSubVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
+  public static <T extends TType> AssignSubVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignSubVariableOp", scope.makeOpName("AssignSubVariableOp"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AssignSubVariableOp(opBuilder.build());
   }
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 0a959b0a191..74209cd615e 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Assigns a new value to a variable.
@@ -44,10 +44,10 @@ public final class AssignVariableOp extends RawOp {
    * @return a new instance of AssignVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AssignVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
+  public static <T extends TType> AssignVariableOp create(Scope scope, Operand<?> resource, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssignVariableOp", scope.makeOpName("AssignVariableOp"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AssignVariableOp(opBuilder.build());
   }
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 dea40abd45c..8f779a3ebbd 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
@@ -177,7 +177,7 @@ public Output<TString> handle() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return handle;
   }
   
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 2b1cbc84c2b..93005265cc2 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
@@ -71,7 +71,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BarrierClose create(Scope scope, Operand<TString> handle, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BarrierClose", scope.makeOpName("BarrierClose"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 62bcdcf1e56..d94c23296a5 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
@@ -44,7 +44,7 @@ public final class BarrierIncompleteSize extends RawOp implements Operand<TInt32
   @Endpoint(describeByClass = true)
   public static BarrierIncompleteSize create(Scope scope, Operand<TString> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("BarrierIncompleteSize", scope.makeOpName("BarrierIncompleteSize"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BarrierIncompleteSize(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 8fa2db8d22b..2b81b8c3812 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * For each key, assigns the respective value to the specified component.
@@ -50,11 +50,11 @@ public final class BarrierInsertMany extends RawOp {
    * @return a new instance of BarrierInsertMany
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BarrierInsertMany create(Scope scope, Operand<TString> handle, Operand<TString> keys, Operand<T> values, Long componentIndex) {
+  public static <T extends TType> BarrierInsertMany create(Scope scope, Operand<TString> handle, Operand<TString> keys, Operand<T> values, Long componentIndex) {
     OperationBuilder opBuilder = scope.env().opBuilder("BarrierInsertMany", scope.makeOpName("BarrierInsertMany"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(keys.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(keys.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("component_index", componentIndex);
     return new BarrierInsertMany(opBuilder.build());
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 b3059b5b8c9..e7897cefc1e 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
@@ -44,7 +44,7 @@ public final class BarrierReadySize extends RawOp implements Operand<TInt32> {
   @Endpoint(describeByClass = true)
   public static BarrierReadySize create(Scope scope, Operand<TString> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("BarrierReadySize", scope.makeOpName("BarrierReadySize"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BarrierReadySize(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 481cdcd1d7a..8983036f436 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
@@ -100,8 +100,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BarrierTakeMany create(Scope scope, Operand<TString> handle, Operand<TInt32> numElements, List<DataType<?>> componentTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BarrierTakeMany", scope.makeOpName("BarrierTakeMany"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(numElements.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(numElements.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] componentTypesArray = new DataType[componentTypes.size()];
     for (int i = 0; i < componentTypesArray.length; ++i) {
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 895ad5e3c77..edcb0a3b6ca 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
@@ -143,7 +143,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Batch create(Scope scope, Iterable<Operand<?>> inTensors, Long numBatchThreads, Long maxBatchSize, Long batchTimeoutMicros, Long gradTimeoutMicros, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Batch", scope.makeOpName("Batch"));
-    opBuilder.addInputList(Operands.asOutputs(inTensors));
+    opBuilder.addInputList(Operands.asOutputs(scope, inTensors));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_batch_threads", numBatchThreads);
     opBuilder.setAttr("max_batch_size", maxBatchSize);
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 1dabeb6aa03..9cd0f18e4ae 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * BatchToSpace for 4-D tensors of type T.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BatchToSpace<T extends Tensor> extends RawOp 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.
@@ -61,10 +61,10 @@ public final class BatchToSpace<T extends Tensor> extends RawOp implements Opera
    * @return a new instance of BatchToSpace
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> BatchToSpace<T> create(Scope scope, Operand<T> input, Operand<U> crops, Long blockSize) {
+  public static <T extends TType, U extends TNumber> BatchToSpace<T> create(Scope scope, Operand<T> input, Operand<U> crops, Long blockSize) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchToSpace", scope.makeOpName("BatchToSpace"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(crops.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(crops.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("block_size", blockSize);
     return new BatchToSpace<T>(opBuilder.build());
@@ -130,7 +130,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 97cba096529..1f8cdf1db56 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * BatchToSpace for N-D tensors of type T.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BatchToSpaceNd<T extends Tensor> extends RawOp 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.
@@ -148,11 +148,11 @@ public final class BatchToSpaceNd<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of BatchToSpaceNd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> BatchToSpaceNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> crops) {
+  public static <T extends TType, U extends TNumber, V extends TNumber> BatchToSpaceNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> crops) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchToSpaceND", scope.makeOpName("BatchToSpaceNd"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(blockShape.asOutput());
-    opBuilder.addInput(crops.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(blockShape.asOutput(scope));
+    opBuilder.addInput(crops.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchToSpaceNd<T>(opBuilder.build());
   }
@@ -164,7 +164,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 e7c8dee1d75..23222c3b913 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Bitcasts a tensor from one type to another without copying data.
@@ -85,7 +85,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Bitcast<U extends Tensor> extends RawOp 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.
@@ -96,9 +96,9 @@ public final class Bitcast<U extends Tensor> extends RawOp implements Operand<U>
    * @return a new instance of Bitcast
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> Bitcast<U> create(Scope scope, Operand<T> input, DataType<U> type) {
+  public static <U extends TType, T extends TType> Bitcast<U> create(Scope scope, Operand<T> input, DataType<U> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("Bitcast", scope.makeOpName("Bitcast"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new Bitcast<U>(opBuilder.build());
@@ -111,7 +111,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 5d50fb142e0..1490e9c8d0a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code r0()} output
  */
 @Operator
-public final class BroadcastDynamicShape<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,10 +47,10 @@ public final class BroadcastDynamicShape<T extends Tensor & TNumber> extends Raw
    * @return a new instance of BroadcastDynamicShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BroadcastDynamicShape<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
+  public static <T extends TNumber> BroadcastDynamicShape<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
     OperationBuilder opBuilder = scope.env().opBuilder("BroadcastArgs", scope.makeOpName("BroadcastDynamicShape"));
-    opBuilder.addInput(s0.asOutput());
-    opBuilder.addInput(s1.asOutput());
+    opBuilder.addInput(s0.asOutput(scope));
+    opBuilder.addInput(s1.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BroadcastDynamicShape<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> r0() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return r0;
   }
   
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 3c14cc20dcd..395e33a6258 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * 
  * @param <T> data type for {@code r0()} output
  */
-public final class BroadcastGradientArgs<T extends Tensor & TNumber> extends RawOp {
+public final class BroadcastGradientArgs<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BroadcastGradientArgs operation.
@@ -46,10 +45,10 @@ public final class BroadcastGradientArgs<T extends Tensor & TNumber> extends Raw
    * @return a new instance of BroadcastGradientArgs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BroadcastGradientArgs<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
+  public static <T extends TNumber> BroadcastGradientArgs<T> create(Scope scope, Operand<T> s0, Operand<T> s1) {
     OperationBuilder opBuilder = scope.env().opBuilder("BroadcastGradientArgs", scope.makeOpName("BroadcastGradientArgs"));
-    opBuilder.addInput(s0.asOutput());
-    opBuilder.addInput(s1.asOutput());
+    opBuilder.addInput(s0.asOutput(scope));
+    opBuilder.addInput(s1.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BroadcastGradientArgs<T>(opBuilder.build());
   }
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 27480128b6f..781a718cb8c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Broadcast an array for a compatible shape.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class BroadcastTo<T extends Tensor> extends RawOp 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.
@@ -64,10 +64,10 @@ public final class BroadcastTo<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of BroadcastTo
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> BroadcastTo<T> create(Scope scope, Operand<T> input, Operand<U> shape) {
+  public static <T extends TType, U extends TNumber> BroadcastTo<T> create(Scope scope, Operand<T> input, Operand<U> shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("BroadcastTo", scope.makeOpName("BroadcastTo"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BroadcastTo<T>(opBuilder.build());
   }
@@ -80,7 +80,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c310c43150a..e28ef23c14c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -56,9 +55,9 @@ public final class Bucketize extends RawOp implements Operand<TInt32> {
    * @return a new instance of Bucketize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Bucketize create(Scope scope, Operand<T> input, List<Float> boundaries) {
+  public static <T extends TNumber> Bucketize create(Scope scope, Operand<T> input, List<Float> boundaries) {
     OperationBuilder opBuilder = scope.env().opBuilder("Bucketize", scope.makeOpName("Bucketize"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     float[] boundariesArray = new float[boundaries.size()];
     for (int i = 0; i < boundariesArray.length; ++i) {
@@ -80,7 +79,7 @@ public Output<TInt32> output() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return output;
   }
   
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 d146af9ebce..eddfbe8c006 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Clips tensor values to a specified min and max.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ClipByValue<T extends Tensor> extends RawOp 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.
@@ -52,11 +52,11 @@ public final class ClipByValue<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of ClipByValue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ClipByValue<T> create(Scope scope, Operand<T> t, Operand<T> clipValueMin, Operand<T> clipValueMax) {
+  public static <T extends TType> ClipByValue<T> create(Scope scope, Operand<T> t, Operand<T> clipValueMin, Operand<T> clipValueMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("ClipByValue", scope.makeOpName("ClipByValue"));
-    opBuilder.addInput(t.asOutput());
-    opBuilder.addInput(clipValueMin.asOutput());
-    opBuilder.addInput(clipValueMax.asOutput());
+    opBuilder.addInput(t.asOutput(scope));
+    opBuilder.addInput(clipValueMin.asOutput(scope));
+    opBuilder.addInput(clipValueMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ClipByValue<T>(opBuilder.build());
   }
@@ -69,7 +69,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 de776adcd3a..7e663151a82 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -34,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CollectiveGather<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class CollectiveGather<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.CollectiveGather}
@@ -68,9 +67,9 @@ private Options() {
    * @return a new instance of CollectiveGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CollectiveGather<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
+  public static <T extends TNumber> CollectiveGather<T> create(Scope scope, Operand<T> input, Long groupSize, Long groupKey, Long instanceKey, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectiveGather", scope.makeOpName("CollectiveGather"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("group_size", groupSize);
     opBuilder.setAttr("group_key", groupKey);
@@ -100,7 +99,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 f48206bf292..27dfab03f3f 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates tensors along one dimension.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Concat<T extends Tensor> extends RawOp 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.
@@ -48,10 +48,10 @@ public final class Concat<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Concat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Concat<T> create(Scope scope, Iterable<Operand<T>> values, Operand<U> axis) {
+  public static <T extends TType, U extends TNumber> Concat<T> create(Scope scope, Iterable<Operand<T>> values, Operand<U> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConcatV2", scope.makeOpName("Concat"));
-    opBuilder.addInputList(Operands.asOutputs(values));
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Concat<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 8a7440297f3..0599e25506f 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
@@ -49,7 +49,7 @@ public final class ConsumeMutexLock extends RawOp {
   @Endpoint(describeByClass = true)
   public static ConsumeMutexLock create(Scope scope, Operand<?> mutexLock) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConsumeMutexLock", scope.makeOpName("ConsumeMutexLock"));
-    opBuilder.addInput(mutexLock.asOutput());
+    opBuilder.addInput(mutexLock.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ConsumeMutexLock(opBuilder.build());
   }
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 103d2239eca..a074e84a211 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Copy a tensor from CPU-to-CPU or GPU-to-GPU.
@@ -42,7 +42,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Copy<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Copy<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Copy}
@@ -85,9 +85,9 @@ private Options() {
    * @return a new instance of Copy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Copy<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> Copy<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Copy", scope.makeOpName("Copy"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -131,7 +131,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 f51be2057ac..6062d28f7ba 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Copy a tensor to host.
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CopyHost<T extends Tensor> extends RawOp implements Operand<T> {
+public final class CopyHost<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.CopyHost}
@@ -83,9 +83,9 @@ private Options() {
    * @return a new instance of CopyHost
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> CopyHost<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> CopyHost<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CopyHost", scope.makeOpName("CopyHost"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -129,7 +129,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 0cc4201156a..7cf7550e53f 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class CountUpTo<T extends Tensor & TNumber> extends RawOp 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.
@@ -46,9 +45,9 @@ public final class CountUpTo<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of CountUpTo
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CountUpTo<T> create(Scope scope, Operand<T> ref, Long limit) {
+  public static <T extends TNumber> CountUpTo<T> create(Scope scope, Operand<T> ref, Long limit) {
     OperationBuilder opBuilder = scope.env().opBuilder("CountUpTo", scope.makeOpName("CountUpTo"));
-    opBuilder.addInput(ref.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("limit", limit);
     return new CountUpTo<T>(opBuilder.build());
@@ -63,7 +62,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 8a423575c08..69f18b67524 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
@@ -137,7 +137,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DecodeProto create(Scope scope, Operand<TString> bytes, String messageType, List<String> fieldNames, List<DataType<?>> outputTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeProtoV2", scope.makeOpName("DecodeProto"));
-    opBuilder.addInput(bytes.asOutput());
+    opBuilder.addInput(bytes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("message_type", messageType);
     String[] fieldNamesArray = new String[fieldNames.size()];
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 e613de3d291..527529a9207 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Makes a copy of `x`.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class DeepCopy<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class DeepCopy<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of DeepCopy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DeepCopy<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> DeepCopy<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeepCopy", scope.makeOpName("DeepCopy"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DeepCopy<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 2da72b19db9..0f3823951ce 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
@@ -42,7 +42,7 @@ public final class DeleteSessionTensor extends RawOp {
   @Endpoint(describeByClass = true)
   public static DeleteSessionTensor create(Scope scope, Operand<TString> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeleteSessionTensor", scope.makeOpName("DeleteSessionTensor"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DeleteSessionTensor(opBuilder.build());
   }
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 dc494cea751..27ff8b78f0e 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
@@ -65,7 +65,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DestroyResourceOp create(Scope scope, Operand<?> resource, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DestroyResourceOp", scope.makeOpName("DestroyResourceOp"));
-    opBuilder.addInput(resource.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 361184cb79c..5bc0358962a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Destroys the temporary variable and returns its final value.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class DestroyTemporaryVariable<T extends Tensor> extends RawOp 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.
@@ -53,9 +53,9 @@ public final class DestroyTemporaryVariable<T extends Tensor> extends RawOp impl
    * @return a new instance of DestroyTemporaryVariable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DestroyTemporaryVariable<T> create(Scope scope, Operand<T> ref, String varName) {
+  public static <T extends TType> DestroyTemporaryVariable<T> create(Scope scope, Operand<T> ref, String varName) {
     OperationBuilder opBuilder = scope.env().opBuilder("DestroyTemporaryVariable", scope.makeOpName("DestroyTemporaryVariable"));
-    opBuilder.addInput(ref.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("var_name", varName);
     return new DestroyTemporaryVariable<T>(opBuilder.build());
@@ -68,7 +68,7 @@ public Output<T> value() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return value;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java
index 14d987e2879..3c0f3c033a2 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/core/DummyMemoryCache.java
@@ -21,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class DummyMemoryCache extends RawOp implements Operand<Tensor> {
+public final class DummyMemoryCache extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DummyMemoryCache operation.
@@ -52,8 +52,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 f749065992e..7878bfed47f 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,12 +24,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Partitions `data` into `num_partitions` tensors using indices from `partitions`.
@@ -71,7 +71,7 @@
  * @param <T> data type for {@code outputs()} output
  */
 @Operator
-public final class DynamicPartition<T extends Tensor> extends RawOp 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.
@@ -83,10 +83,10 @@ public final class DynamicPartition<T extends Tensor> extends RawOp implements I
    * @return a new instance of DynamicPartition
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DynamicPartition<T> create(Scope scope, Operand<T> data, Operand<TInt32> partitions, Long numPartitions) {
+  public static <T extends TType> DynamicPartition<T> create(Scope scope, Operand<T> data, Operand<TInt32> partitions, Long numPartitions) {
     OperationBuilder opBuilder = scope.env().opBuilder("DynamicPartition", scope.makeOpName("DynamicPartition"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(partitions.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(partitions.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_partitions", numPartitions);
     return new DynamicPartition<T>(opBuilder.build());
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 2fd2206f798..79cba09d6eb 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Interleave the values from the `data` tensors into a single tensor.
@@ -90,7 +90,7 @@
  * @param <T> data type for {@code merged()} output
  */
 @Operator
-public final class DynamicStitch<T extends Tensor> extends RawOp 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.
@@ -101,10 +101,10 @@ public final class DynamicStitch<T extends Tensor> extends RawOp implements Oper
    * @return a new instance of DynamicStitch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
+  public static <T extends TType> DynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("DynamicStitch", scope.makeOpName("DynamicStitch"));
-    opBuilder.addInputList(Operands.asOutputs(indices));
-    opBuilder.addInputList(Operands.asOutputs(data));
+    opBuilder.addInputList(Operands.asOutputs(scope, indices));
+    opBuilder.addInputList(Operands.asOutputs(scope, data));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DynamicStitch<T>(opBuilder.build());
   }
@@ -116,7 +116,7 @@ public Output<T> merged() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return merged;
   }
   
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 6c799f18e0b..7a3583a8e5a 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the (possibly normalized) Levenshtein Edit Distance.
@@ -82,14 +82,14 @@ private Options() {
    * @return a new instance of EditDistance
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> EditDistance create(Scope scope, Operand<TInt64> hypothesisIndices, Operand<T> hypothesisValues, Operand<TInt64> hypothesisShape, Operand<TInt64> truthIndices, Operand<T> truthValues, Operand<TInt64> truthShape, Options... options) {
+  public static <T extends TType> EditDistance create(Scope scope, Operand<TInt64> hypothesisIndices, Operand<T> hypothesisValues, Operand<TInt64> hypothesisShape, Operand<TInt64> truthIndices, Operand<T> truthValues, Operand<TInt64> truthShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EditDistance", scope.makeOpName("EditDistance"));
-    opBuilder.addInput(hypothesisIndices.asOutput());
-    opBuilder.addInput(hypothesisValues.asOutput());
-    opBuilder.addInput(hypothesisShape.asOutput());
-    opBuilder.addInput(truthIndices.asOutput());
-    opBuilder.addInput(truthValues.asOutput());
-    opBuilder.addInput(truthShape.asOutput());
+    opBuilder.addInput(hypothesisIndices.asOutput(scope));
+    opBuilder.addInput(hypothesisValues.asOutput(scope));
+    opBuilder.addInput(hypothesisShape.asOutput(scope));
+    opBuilder.addInput(truthIndices.asOutput(scope));
+    opBuilder.addInput(truthValues.asOutput(scope));
+    opBuilder.addInput(truthShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -147,7 +147,7 @@ public Output<TFloat32> output() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return output;
   }
   
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 ce7d5566cca..ff03c154af0 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a tensor with the given shape.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Empty<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Empty<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Empty}
@@ -68,9 +68,9 @@ private Options() {
    * @return a new instance of Empty
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Empty<T> create(Scope scope, Operand<TInt32> shape, DataType<T> dtype, Options... options) {
+  public static <T extends TType> Empty<T> create(Scope scope, Operand<TInt32> shape, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Empty", scope.makeOpName("Empty"));
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -98,7 +98,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 9421ee881c1..7a73f068593 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates and returns an empty tensor list.
@@ -41,7 +41,7 @@
  * element_shape: a shape compatible with that of elements in the list.
  */
 @Operator
-public final class EmptyTensorList extends RawOp implements Operand<Tensor> {
+public final class EmptyTensorList extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new EmptyTensorList operation.
@@ -53,10 +53,10 @@ public final class EmptyTensorList extends RawOp implements Operand<Tensor> {
    * @return a new instance of EmptyTensorList
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> EmptyTensorList create(Scope scope, Operand<T> elementShape, Operand<TInt32> maxNumElements, DataType<U> elementDtype) {
+  public static <T extends TNumber, U extends TType> EmptyTensorList create(Scope scope, Operand<T> elementShape, Operand<TInt32> maxNumElements, DataType<U> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("EmptyTensorList", scope.makeOpName("EmptyTensorList"));
-    opBuilder.addInput(elementShape.asOutput());
-    opBuilder.addInput(maxNumElements.asOutput());
+    opBuilder.addInput(elementShape.asOutput(scope));
+    opBuilder.addInput(maxNumElements.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     return new EmptyTensorList(opBuilder.build());
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 6f2e448d053..f0754def839 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
@@ -109,8 +109,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static EncodeProto create(Scope scope, Operand<TInt32> sizes, Iterable<Operand<?>> values, List<String> fieldNames, String messageType, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EncodeProto", scope.makeOpName("EncodeProto"));
-    opBuilder.addInput(sizes.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(values));
+    opBuilder.addInput(sizes.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
     opBuilder = scope.applyControlDependencies(opBuilder);
     String[] fieldNamesArray = new String[fieldNames.size()];
     for (int i = 0; i < fieldNamesArray.length; ++i) {
@@ -143,7 +143,7 @@ public Output<TString> bytes() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return bytes;
   }
   
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 8728cfb6601..8bad2890370 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Ensures that the tensor's shape matches the expected shape.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class EnsureShape<T extends Tensor> extends RawOp 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.
@@ -48,9 +48,9 @@ public final class EnsureShape<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of EnsureShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> EnsureShape<T> create(Scope scope, Operand<T> input, Shape shape) {
+  public static <T extends TType> EnsureShape<T> create(Scope scope, Operand<T> input, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("EnsureShape", scope.makeOpName("EnsureShape"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
     return new EnsureShape<T>(opBuilder.build());
@@ -64,7 +64,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 6a658622e76..3ccb8d1b9b9 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates or finds a child frame, and makes `data` available to the child frame.
@@ -38,7 +38,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Enter<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Enter<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Enter}
@@ -78,9 +78,9 @@ private Options() {
    * @return a new instance of Enter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Enter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
+  public static <T extends TType> Enter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Enter", scope.makeOpName("Enter"));
-    opBuilder.addInput(data.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("frame_name", frameName);
     if (options != null) {
@@ -118,7 +118,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c23aa50ea5c..57b9c871151 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Exits the current frame to its parent frame.
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class Exit<T extends Tensor> extends RawOp 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.
@@ -44,9 +44,9 @@ public final class Exit<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Exit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Exit<T> create(Scope scope, Operand<T> data) {
+  public static <T extends TType> Exit<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("Exit", scope.makeOpName("Exit"));
-    opBuilder.addInput(data.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Exit<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 85a271d08bd..4493f8ebf59 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Inserts a dimension of 1 into a tensor's shape.
@@ -63,7 +63,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ExpandDims<T extends Tensor> extends RawOp 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.
@@ -76,10 +76,10 @@ public final class ExpandDims<T extends Tensor> extends RawOp implements Operand
    * @return a new instance of ExpandDims
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ExpandDims<T> create(Scope scope, Operand<T> input, Operand<U> axis) {
+  public static <T extends TType, U extends TNumber> ExpandDims<T> create(Scope scope, Operand<T> input, Operand<U> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExpandDims", scope.makeOpName("ExpandDims"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ExpandDims<T>(opBuilder.build());
   }
@@ -93,7 +93,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 d5d4b616149..78f589a8bf3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code patches()} output
  */
 @Operator
-public final class ExtractVolumePatches<T extends Tensor & TNumber> extends RawOp 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.
@@ -56,9 +55,9 @@ public final class ExtractVolumePatches<T extends Tensor & TNumber> extends RawO
    * @return a new instance of ExtractVolumePatches
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ExtractVolumePatches<T> create(Scope scope, Operand<T> input, List<Long> ksizes, List<Long> strides, String padding) {
+  public static <T extends TNumber> ExtractVolumePatches<T> create(Scope scope, Operand<T> input, List<Long> ksizes, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExtractVolumePatches", scope.makeOpName("ExtractVolumePatches"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizesArray = new long[ksizes.size()];
     for (int i = 0; i < ksizesArray.length; ++i) {
@@ -86,7 +85,7 @@ public Output<T> patches() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return patches;
   }
   
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 b42deb2ebd9..48f1128fa9c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a tensor filled with a scalar value.
@@ -57,7 +57,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Fill<U extends Tensor> extends RawOp 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.
@@ -72,10 +72,10 @@ public final class Fill<U extends Tensor> extends RawOp implements Operand<U> {
    * @return a new instance of Fill
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> Fill<U> create(Scope scope, Operand<T> dims, Operand<U> value) {
+  public static <U extends TType, T extends TNumber> Fill<U> create(Scope scope, Operand<T> dims, Operand<U> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("Fill", scope.makeOpName("Fill"));
-    opBuilder.addInput(dims.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(dims.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Fill<U>(opBuilder.build());
   }
@@ -87,7 +87,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 4780506ec70..805470b9090 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.TUint8;
+import org.tensorflow.types.family.TType;
 
 /**
  * Generates fingerprint values.
@@ -74,10 +74,10 @@ public final class Fingerprint extends RawOp implements Operand<TUint8> {
    * @return a new instance of Fingerprint
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Fingerprint create(Scope scope, Operand<T> data, Operand<TString> method) {
+  public static <T extends TType> Fingerprint create(Scope scope, Operand<T> data, Operand<TString> method) {
     OperationBuilder opBuilder = scope.env().opBuilder("Fingerprint", scope.makeOpName("Fingerprint"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(method.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(method.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Fingerprint(opBuilder.build());
   }
@@ -92,7 +92,7 @@ public Output<TUint8> fingerprint() {
   }
   
   @Override
-  public Output<TUint8> asOutput() {
+  public Output<TUint8> asOutput(Scope scope) {
     return fingerprint;
   }
   
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 fb8a6a8adc0..869f2aa7b9a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gather slices from `params` axis `axis` according to `indices`.
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Gather<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Gather<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Gather}
@@ -94,11 +94,11 @@ private Options() {
    * @return a new instance of Gather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Gather<T> create(Scope scope, Operand<T> params, Operand<U> indices, Operand<V> axis, Options... options) {
+  public static <T extends TType, U extends TNumber, V extends TNumber> Gather<T> create(Scope scope, Operand<T> params, Operand<U> indices, Operand<V> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("GatherV2", scope.makeOpName("Gather"));
-    opBuilder.addInput(params.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(params.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -126,7 +126,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 eb51695d54f..9252c66d2f6 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gather slices from `params` into a Tensor with shape specified by `indices`.
@@ -127,7 +127,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class GatherNd<T extends Tensor> extends RawOp 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.
@@ -138,10 +138,10 @@ public final class GatherNd<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of GatherNd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> GatherNd<T> create(Scope scope, Operand<T> params, Operand<U> indices) {
+  public static <T extends TType, U extends TNumber> GatherNd<T> create(Scope scope, Operand<T> params, Operand<U> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("GatherNd", scope.makeOpName("GatherNd"));
-    opBuilder.addInput(params.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(params.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new GatherNd<T>(opBuilder.build());
   }
@@ -155,7 +155,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 e69c217ec92..6c594068b02 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Store the input tensor in the state of the current session.
  */
 @Operator
-public final class GetSessionHandle extends RawOp implements Operand<Tensor> {
+public final class GetSessionHandle extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new GetSessionHandle operation.
@@ -41,9 +41,9 @@ public final class GetSessionHandle extends RawOp implements Operand<Tensor> {
    * @return a new instance of GetSessionHandle
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> GetSessionHandle create(Scope scope, Operand<T> value) {
+  public static <T extends TType> GetSessionHandle create(Scope scope, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("GetSessionHandleV2", scope.makeOpName("GetSessionHandle"));
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new GetSessionHandle(opBuilder.build());
   }
@@ -58,8 +58,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 46deb48db0d..09623f69e75 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Get the value of the tensor specified by its handle.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class GetSessionTensor<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class GetSessionTensor<T extends Tensor> extends RawOp implements O
    * @return a new instance of GetSessionTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> GetSessionTensor<T> create(Scope scope, Operand<TString> handle, DataType<T> dtype) {
+  public static <T extends TType> GetSessionTensor<T> create(Scope scope, Operand<TString> handle, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("GetSessionTensor", scope.makeOpName("GetSessionTensor"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new GetSessionTensor<T>(opBuilder.build());
@@ -62,7 +62,7 @@ public Output<T> value() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return value;
   }
   
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 4bd03d89ad7..d1a9cfae678 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gives a guarantee to the TF runtime that the input tensor is a constant.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class GuaranteeConst<T extends Tensor> extends RawOp 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.
@@ -50,9 +50,9 @@ public final class GuaranteeConst<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of GuaranteeConst
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> GuaranteeConst<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> GuaranteeConst<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("GuaranteeConst", scope.makeOpName("GuaranteeConst"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new GuaranteeConst<T>(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 134386e256a..c6596ce9ce3 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a non-initialized hash table.
@@ -36,7 +36,7 @@
  * table will be immutable.
  */
 @Operator
-public final class HashTable extends RawOp implements Operand<Tensor> {
+public final class HashTable extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.HashTable}
@@ -88,7 +88,7 @@ private Options() {
    * @return a new instance of HashTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> HashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
+  public static <T extends TType, U extends TType> HashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("HashTableV2", scope.makeOpName("HashTable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("key_dtype", keyDtype);
@@ -142,8 +142,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) tableHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 a347ff9c50c..163f36b6edf 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -52,7 +51,7 @@
  * @param <U> data type for {@code out()} output
  */
 @Operator
-public final class HistogramFixedWidth<U extends Tensor & TNumber> extends RawOp 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.
@@ -67,11 +66,11 @@ public final class HistogramFixedWidth<U extends Tensor & TNumber> extends RawOp
    * @return a new instance of HistogramFixedWidth
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> HistogramFixedWidth<U> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins, DataType<U> dtype) {
+  public static <U extends TNumber, T extends TNumber> HistogramFixedWidth<U> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("HistogramFixedWidth", scope.makeOpName("HistogramFixedWidth"));
-    opBuilder.addInput(values.asOutput());
-    opBuilder.addInput(valueRange.asOutput());
-    opBuilder.addInput(nbins.asOutput());
+    opBuilder.addInput(values.asOutput(scope));
+    opBuilder.addInput(valueRange.asOutput(scope));
+    opBuilder.addInput(nbins.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new HistogramFixedWidth<U>(opBuilder.build());
@@ -89,7 +88,7 @@ public static <U extends Tensor & TNumber, T extends Tensor & TNumber> Histogram
    * @return a new instance of HistogramFixedWidth
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> HistogramFixedWidth<TInt32> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins) {
+  public static <T extends TNumber> HistogramFixedWidth<TInt32> create(Scope scope, Operand<T> values, Operand<T> valueRange, Operand<TInt32> nbins) {
     return create(scope, values, valueRange, nbins, TInt32.DTYPE);
   }
   
@@ -101,7 +100,7 @@ public Output<U> out() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return out;
   }
   
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 6a3720ffebe..f72d6c30e1a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Return a tensor with the same shape and contents as the input tensor or value.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Identity<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class Identity<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of Identity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Identity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Identity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Identity", scope.makeOpName("Identity"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Identity<T>(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 dd12da05233..3cb1097e328 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
@@ -24,12 +24,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a list of tensors with the same shapes and contents as the input
@@ -51,7 +51,7 @@
  * 
  */
 @Operator
-public final class IdentityN extends RawOp implements Iterable<Operand<Tensor>> {
+public final class IdentityN extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new IdentityN operation.
@@ -63,7 +63,7 @@ public final class IdentityN extends RawOp implements Iterable<Operand<Tensor>>
   @Endpoint(describeByClass = true)
   public static IdentityN create(Scope scope, Iterable<Operand<?>> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("IdentityN", scope.makeOpName("IdentityN"));
-    opBuilder.addInputList(Operands.asOutputs(input));
+    opBuilder.addInputList(Operands.asOutputs(scope, input));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IdentityN(opBuilder.build());
   }
@@ -76,7 +76,7 @@ public List<Output<?>> output() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) output.iterator();
   }
   
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 fc1e39fba9c..c5cbe6b86ac 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns immutable tensor from memory region.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class ImmutableConst<T extends Tensor> extends RawOp 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.
@@ -50,7 +50,7 @@ public final class ImmutableConst<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of ImmutableConst
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ImmutableConst<T> create(Scope scope, DataType<T> dtype, Shape shape, String memoryRegionName) {
+  public static <T extends TType> ImmutableConst<T> create(Scope scope, DataType<T> dtype, Shape shape, String memoryRegionName) {
     OperationBuilder opBuilder = scope.env().opBuilder("ImmutableConst", scope.makeOpName("ImmutableConst"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -66,7 +66,7 @@ public Output<T> tensor() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return tensor;
   }
   
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 00e2ec45e07..75b8d08e0de 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Table initializer that takes two tensors for keys and values respectively.
@@ -42,11 +42,11 @@ public final class InitializeTable extends RawOp {
    * @return a new instance of InitializeTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> InitializeTable create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+  public static <T extends TType, U extends TType> InitializeTable create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("InitializeTableV2", scope.makeOpName("InitializeTable"));
-    opBuilder.addInput(tableHandle.asOutput());
-    opBuilder.addInput(keys.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
+    opBuilder.addInput(keys.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new InitializeTable(opBuilder.build());
   }
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 672bf052e49..7497f72375c 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
@@ -86,8 +86,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static InitializeTableFromTextFile create(Scope scope, Operand<?> tableHandle, Operand<TString> filename, Long keyIndex, Long valueIndex, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("InitializeTableFromTextFileV2", scope.makeOpName("InitializeTableFromTextFile"));
-    opBuilder.addInput(tableHandle.asOutput());
-    opBuilder.addInput(filename.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
+    opBuilder.addInput(filename.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("key_index", keyIndex);
     opBuilder.setAttr("value_index", valueIndex);
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 e5940ee9911..326ffc75b00 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  *     Adds v into specified rows of x.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceAdd<T extends Tensor> extends RawOp 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.
@@ -48,11 +48,11 @@ public final class InplaceAdd<T extends Tensor> extends RawOp implements Operand
    * @return a new instance of InplaceAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> InplaceAdd<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public static <T extends TType> InplaceAdd<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     OperationBuilder opBuilder = scope.env().opBuilder("InplaceAdd", scope.makeOpName("InplaceAdd"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(i.asOutput());
-    opBuilder.addInput(v.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(i.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new InplaceAdd<T>(opBuilder.build());
   }
@@ -65,7 +65,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 74d7e6ee18a..aab7ceb3411 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  *     Subtracts `v` into specified rows of `x`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceSub<T extends Tensor> extends RawOp 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.
@@ -48,11 +48,11 @@ public final class InplaceSub<T extends Tensor> extends RawOp implements Operand
    * @return a new instance of InplaceSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> InplaceSub<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public static <T extends TType> InplaceSub<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     OperationBuilder opBuilder = scope.env().opBuilder("InplaceSub", scope.makeOpName("InplaceSub"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(i.asOutput());
-    opBuilder.addInput(v.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(i.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new InplaceSub<T>(opBuilder.build());
   }
@@ -65,7 +65,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 469d1364aea..e7697124fe6 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  *     Updates specified rows with values in `v`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class InplaceUpdate<T extends Tensor> extends RawOp 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.
@@ -48,11 +48,11 @@ public final class InplaceUpdate<T extends Tensor> extends RawOp implements Oper
    * @return a new instance of InplaceUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> InplaceUpdate<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
+  public static <T extends TType> InplaceUpdate<T> create(Scope scope, Operand<T> x, Operand<TInt32> i, Operand<T> v) {
     OperationBuilder opBuilder = scope.env().opBuilder("InplaceUpdate", scope.makeOpName("InplaceUpdate"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(i.asOutput());
-    opBuilder.addInput(v.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(i.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new InplaceUpdate<T>(opBuilder.build());
   }
@@ -65,7 +65,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 3e656564880..f5d4cc53b57 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * Checks whether a tensor has been initialized.
@@ -44,9 +44,9 @@ public final class IsVariableInitialized extends RawOp implements Operand<TBool>
    * @return a new instance of IsVariableInitialized
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> IsVariableInitialized create(Scope scope, Operand<T> ref) {
+  public static <T extends TType> IsVariableInitialized create(Scope scope, Operand<T> ref) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsVariableInitialized", scope.makeOpName("IsVariableInitialized"));
-    opBuilder.addInput(ref.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IsVariableInitialized(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TBool> isInitialized() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return isInitialized;
   }
   
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 3162c4eec68..d2061ea6553 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -44,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class LinSpace<T extends Tensor & TNumber> extends RawOp 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.
@@ -56,11 +55,11 @@ public final class LinSpace<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of LinSpace
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> LinSpace<T> create(Scope scope, Operand<T> start, Operand<T> stop, Operand<U> num) {
+  public static <T extends TNumber, U extends TNumber> LinSpace<T> create(Scope scope, Operand<T> start, Operand<T> stop, Operand<U> num) {
     OperationBuilder opBuilder = scope.env().opBuilder("LinSpace", scope.makeOpName("LinSpace"));
-    opBuilder.addInput(start.asOutput());
-    opBuilder.addInput(stop.asOutput());
-    opBuilder.addInput(num.asOutput());
+    opBuilder.addInput(start.asOutput(scope));
+    opBuilder.addInput(stop.asOutput(scope));
+    opBuilder.addInput(num.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LinSpace<T>(opBuilder.build());
   }
@@ -73,7 +72,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 45a2a2bb892..cc49d7b0584 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs all keys and values in the table.
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code values()} output
  */
 @Operator
-public final class LookupTableExport<T extends Tensor, U extends Tensor> extends RawOp {
+public final class LookupTableExport<T extends TType, U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LookupTableExport operation.
@@ -47,9 +47,9 @@ public final class LookupTableExport<T extends Tensor, U extends Tensor> extends
    * @return a new instance of LookupTableExport
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> LookupTableExport<T, U> create(Scope scope, Operand<?> tableHandle, DataType<T> Tkeys, DataType<U> Tvalues) {
+  public static <T extends TType, U extends TType> LookupTableExport<T, U> create(Scope scope, Operand<?> tableHandle, DataType<T> Tkeys, DataType<U> Tvalues) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableExportV2", scope.makeOpName("LookupTableExport"));
-    opBuilder.addInput(tableHandle.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tkeys", Tkeys);
     opBuilder.setAttr("Tvalues", Tvalues);
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 581d1489924..a0005ceccf2 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Looks up keys in a table, outputs the corresponding values.
@@ -39,7 +39,7 @@
  * @param <U> data type for {@code values()} output
  */
 @Operator
-public final class LookupTableFind<U extends Tensor> extends RawOp 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.
@@ -51,11 +51,11 @@ public final class LookupTableFind<U extends Tensor> extends RawOp implements Op
    * @return a new instance of LookupTableFind
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> LookupTableFind<U> create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> defaultValue) {
+  public static <U extends TType, T extends TType> LookupTableFind<U> create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> defaultValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableFindV2", scope.makeOpName("LookupTableFind"));
-    opBuilder.addInput(tableHandle.asOutput());
-    opBuilder.addInput(keys.asOutput());
-    opBuilder.addInput(defaultValue.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
+    opBuilder.addInput(keys.asOutput(scope));
+    opBuilder.addInput(defaultValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LookupTableFind<U>(opBuilder.build());
   }
@@ -69,7 +69,7 @@ public Output<U> values() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return values;
   }
   
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 604697c002e..93f03cec838 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Replaces the contents of the table with the specified keys and values.
@@ -45,11 +45,11 @@ public final class LookupTableImport extends RawOp {
    * @return a new instance of LookupTableImport
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> LookupTableImport create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+  public static <T extends TType, U extends TType> LookupTableImport create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableImportV2", scope.makeOpName("LookupTableImport"));
-    opBuilder.addInput(tableHandle.asOutput());
-    opBuilder.addInput(keys.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
+    opBuilder.addInput(keys.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LookupTableImport(opBuilder.build());
   }
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 13c58a8ff9a..d698ad21a2b 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Updates the table to associates keys with values.
@@ -45,11 +45,11 @@ public final class LookupTableInsert extends RawOp {
    * @return a new instance of LookupTableInsert
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> LookupTableInsert create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
+  public static <T extends TType, U extends TType> LookupTableInsert create(Scope scope, Operand<?> tableHandle, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableInsertV2", scope.makeOpName("LookupTableInsert"));
-    opBuilder.addInput(tableHandle.asOutput());
-    opBuilder.addInput(keys.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
+    opBuilder.addInput(keys.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LookupTableInsert(opBuilder.build());
   }
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 15f9c2590c4..2533d50a1dd 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Removes keys and its associated values from a table.
@@ -43,10 +43,10 @@ public final class LookupTableRemove extends RawOp {
    * @return a new instance of LookupTableRemove
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> LookupTableRemove create(Scope scope, Operand<?> tableHandle, Operand<T> keys) {
+  public static <T extends TType> LookupTableRemove create(Scope scope, Operand<?> tableHandle, Operand<T> keys) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableRemoveV2", scope.makeOpName("LookupTableRemove"));
-    opBuilder.addInput(tableHandle.asOutput());
-    opBuilder.addInput(keys.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
+    opBuilder.addInput(keys.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LookupTableRemove(opBuilder.build());
   }
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 441c2208bd3..177cbfa202d 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
@@ -43,7 +43,7 @@ public final class LookupTableSize extends RawOp implements Operand<TInt64> {
   @Endpoint(describeByClass = true)
   public static LookupTableSize create(Scope scope, Operand<?> tableHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("LookupTableSizeV2", scope.makeOpName("LookupTableSize"));
-    opBuilder.addInput(tableHandle.asOutput());
+    opBuilder.addInput(tableHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LookupTableSize(opBuilder.build());
   }
@@ -56,7 +56,7 @@ public Output<TInt64> size() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return size;
   }
   
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 bef80f40840..54e7c9c10e1 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
@@ -46,7 +46,7 @@ public final class LoopCond extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static LoopCond create(Scope scope, Operand<TBool> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoopCond", scope.makeOpName("LoopCond"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LoopCond(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 7cb4485236e..98d2aa86af8 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies lower_bound(sorted_search_values, values) along each row.
@@ -53,7 +53,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class LowerBound<U extends Tensor & TNumber> extends RawOp 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.
@@ -66,10 +66,10 @@ public final class LowerBound<U extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of LowerBound
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> LowerBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
+  public static <U extends TNumber, T extends TType> LowerBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("LowerBound", scope.makeOpName("LowerBound"));
-    opBuilder.addInput(sortedInputs.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(sortedInputs.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new LowerBound<U>(opBuilder.build());
@@ -85,7 +85,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> LowerBound<U> creat
    * @return a new instance of LowerBound
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> LowerBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
+  public static <T extends TType> LowerBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
     return create(scope, sortedInputs, values, TInt32.DTYPE);
   }
   
@@ -99,7 +99,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 a4522bb2993..3267bb3b931 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
@@ -152,7 +152,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 7e136a14822..1fde7d050de 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Op peeks at the values at the specified key.  If the
@@ -40,7 +40,7 @@
  * this op will block until it does.
  */
 @Operator
-public final class MapPeek extends RawOp implements Iterable<Operand<Tensor>> {
+public final class MapPeek extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapPeek}
@@ -101,8 +101,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static MapPeek create(Scope scope, Operand<TInt64> key, Operand<TInt32> indices, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MapPeek", scope.makeOpName("MapPeek"));
-    opBuilder.addInput(key.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(key.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
@@ -164,7 +164,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 20a2b619d1e..50b5a31a9c1 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
@@ -152,7 +152,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 cc09bdf78a2..80e92c3fad3 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
@@ -99,9 +99,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static MapStage create(Scope scope, Operand<TInt64> key, Operand<TInt32> indices, Iterable<Operand<?>> values, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MapStage", scope.makeOpName("MapStage"));
-    opBuilder.addInput(key.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(values));
+    opBuilder.addInput(key.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
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 bff36a20782..31d43156baf 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Op removes and returns the values associated with the key
@@ -40,7 +40,7 @@
  * does not contain this key, the op will block until it does.
  */
 @Operator
-public final class MapUnstage extends RawOp implements Iterable<Operand<Tensor>> {
+public final class MapUnstage extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MapUnstage}
@@ -101,8 +101,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static MapUnstage create(Scope scope, Operand<TInt64> key, Operand<TInt32> indices, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MapUnstage", scope.makeOpName("MapUnstage"));
-    opBuilder.addInput(key.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(key.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
@@ -164,7 +164,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 a915362108e..0c465f9f4c2 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
@@ -98,7 +98,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static MapUnstageNoKey create(Scope scope, Operand<TInt32> indices, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MapUnstageNoKey", scope.makeOpName("MapUnstageNoKey"));
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
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 6c91d8d82da..56547e63cc3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the maximum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Max<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Max<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Max}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of Max
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Max<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> Max<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Max", scope.makeOpName("Max"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 bb8bf519b66..7712333963d 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the value of an available tensor from `inputs` to `output`.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Merge<T extends Tensor> extends RawOp {
+public final class Merge<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Merge operation.
@@ -51,9 +51,9 @@ public final class Merge<T extends Tensor> extends RawOp {
    * @return a new instance of Merge
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Merge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
+  public static <T extends TType> Merge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("Merge", scope.makeOpName("Merge"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Merge<T>(opBuilder.build());
   }
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 6e2733701c7..4bd92de204a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the minimum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Min<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Min<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Min}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of Min
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Min<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> Min<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Min", scope.makeOpName("Min"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 1049cde4500..c7ef1099f86 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Pads a tensor with mirrored values.
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class MirrorPad<T extends Tensor> extends RawOp 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.
@@ -77,10 +77,10 @@ public final class MirrorPad<T extends Tensor> extends RawOp implements Operand<
    * @return a new instance of MirrorPad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> MirrorPad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
+  public static <T extends TType, U extends TNumber> MirrorPad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
     OperationBuilder opBuilder = scope.env().opBuilder("MirrorPad", scope.makeOpName("MirrorPad"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(paddings.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(paddings.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("mode", mode);
     return new MirrorPad<T>(opBuilder.build());
@@ -94,7 +94,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5a89f007c87..720cfb98545 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gradient op for `MirrorPad` op. This op folds a mirror-padded tensor.
@@ -52,7 +52,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MirrorPadGrad<T extends Tensor> extends RawOp 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.
@@ -65,10 +65,10 @@ public final class MirrorPadGrad<T extends Tensor> extends RawOp implements Oper
    * @return a new instance of MirrorPadGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> MirrorPadGrad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
+  public static <T extends TType, U extends TNumber> MirrorPadGrad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, String mode) {
     OperationBuilder opBuilder = scope.env().opBuilder("MirrorPadGrad", scope.makeOpName("MirrorPadGrad"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(paddings.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(paddings.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("mode", mode);
     return new MirrorPadGrad<T>(opBuilder.build());
@@ -82,7 +82,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 9bed12a1771..c43407e2e1b 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
@@ -25,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps an arbitrary MLIR computation expressed as a module with a main() function.
@@ -66,7 +66,7 @@
  * 
  */
 @Operator
-public final class MlirPassthroughOp extends RawOp implements Iterable<Operand<Tensor>> {
+public final class MlirPassthroughOp extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new MlirPassthroughOp operation.
@@ -80,7 +80,7 @@ public final class MlirPassthroughOp extends RawOp implements Iterable<Operand<T
   @Endpoint(describeByClass = true)
   public static MlirPassthroughOp create(Scope scope, Iterable<Operand<?>> inputs, String mlirModule, List<DataType<?>> Toutputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("MlirPassthroughOp", scope.makeOpName("MlirPassthroughOp"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("mlir_module", mlirModule);
     DataType[] ToutputsArray = new DataType[Toutputs.size()];
@@ -99,7 +99,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 efb8f620677..022ca0627ff 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates an empty hash table that uses tensors as the backing store.
@@ -40,7 +40,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableDenseHashTable extends RawOp implements Operand<Tensor> {
+public final class MutableDenseHashTable extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableDenseHashTable}
@@ -122,10 +122,10 @@ private Options() {
    * @return a new instance of MutableDenseHashTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> MutableDenseHashTable create(Scope scope, Operand<T> emptyKey, Operand<T> deletedKey, DataType<U> valueDtype, Options... options) {
+  public static <T extends TType, U extends TType> MutableDenseHashTable create(Scope scope, Operand<T> emptyKey, Operand<T> deletedKey, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MutableDenseHashTableV2", scope.makeOpName("MutableDenseHashTable"));
-    opBuilder.addInput(emptyKey.asOutput());
-    opBuilder.addInput(deletedKey.asOutput());
+    opBuilder.addInput(emptyKey.asOutput(scope));
+    opBuilder.addInput(deletedKey.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("value_dtype", valueDtype);
     if (options != null) {
@@ -208,8 +208,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) tableHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 89cb8f69bbf..9ef0ae419bd 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates an empty hash table.
@@ -36,7 +36,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableHashTable extends RawOp implements Operand<Tensor> {
+public final class MutableHashTable extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableHashTable}
@@ -88,7 +88,7 @@ private Options() {
    * @return a new instance of MutableHashTable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> MutableHashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
+  public static <T extends TType, U extends TType> MutableHashTable create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MutableHashTableV2", scope.makeOpName("MutableHashTable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("key_dtype", keyDtype);
@@ -142,8 +142,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) tableHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 89ba23e3c97..5722231a2ab 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates an empty hash table.
@@ -37,7 +37,7 @@
  * the insert operations. It does not support the initialization operation.
  */
 @Operator
-public final class MutableHashTableOfTensors extends RawOp implements Operand<Tensor> {
+public final class MutableHashTableOfTensors extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.MutableHashTableOfTensors}
@@ -97,7 +97,7 @@ private Options() {
    * @return a new instance of MutableHashTableOfTensors
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> MutableHashTableOfTensors create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
+  public static <T extends TType, U extends TType> MutableHashTableOfTensors create(Scope scope, DataType<T> keyDtype, DataType<U> valueDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MutableHashTableOfTensorsV2", scope.makeOpName("MutableHashTableOfTensors"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("key_dtype", keyDtype);
@@ -160,8 +160,8 @@ public Output<?> tableHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) tableHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) tableHandle;
   }
   
   private Output<?> tableHandle;
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 aa613872961..98a79430da9 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Mutex resource that can be locked by `MutexLock`.
  */
 @Operator
-public final class Mutex extends RawOp implements Operand<Tensor> {
+public final class Mutex extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Mutex}
@@ -112,8 +112,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) resource;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) resource;
   }
   
   private Output<?> resource;
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 f2a07afa04a..e1adfbb5a7e 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Locks a mutex resource.  The output is the lock.  So long as the lock tensor
@@ -67,7 +67,7 @@
  * wish to ensure the usage is exclusive.
  */
 @Operator
-public final class MutexLock extends RawOp implements Operand<Tensor> {
+public final class MutexLock extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MutexLock operation.
@@ -79,7 +79,7 @@ public final class MutexLock extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static MutexLock create(Scope scope, Operand<?> mutex) {
     OperationBuilder opBuilder = scope.env().opBuilder("MutexLock", scope.makeOpName("MutexLock"));
-    opBuilder.addInput(mutex.asOutput());
+    opBuilder.addInput(mutex.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MutexLock(opBuilder.build());
   }
@@ -95,8 +95,8 @@ public Output<?> mutexLock() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) mutexLock;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) mutexLock;
   }
   
   private Output<?> mutexLock;
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 bd552cbaf0a..4c0f79434a3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -46,7 +45,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclAllReduce<T extends Tensor & TNumber> extends RawOp 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.
@@ -59,9 +58,9 @@ public final class NcclAllReduce<T extends Tensor & TNumber> extends RawOp imple
    * @return a new instance of NcclAllReduce
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> NcclAllReduce<T> create(Scope scope, Operand<T> input, String reduction, Long numDevices, String sharedName) {
+  public static <T extends TNumber> NcclAllReduce<T> create(Scope scope, Operand<T> input, String reduction, Long numDevices, String sharedName) {
     OperationBuilder opBuilder = scope.env().opBuilder("NcclAllReduce", scope.makeOpName("NcclAllReduce"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("reduction", reduction);
     opBuilder.setAttr("num_devices", numDevices);
@@ -76,7 +75,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 42b2740b667..aa02635dd52 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -44,7 +43,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclBroadcast<T extends Tensor & TNumber> extends RawOp 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.
@@ -55,9 +54,9 @@ public final class NcclBroadcast<T extends Tensor & TNumber> extends RawOp imple
    * @return a new instance of NcclBroadcast
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> NcclBroadcast<T> create(Scope scope, Operand<T> input, Shape shape) {
+  public static <T extends TNumber> NcclBroadcast<T> create(Scope scope, Operand<T> input, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("NcclBroadcast", scope.makeOpName("NcclBroadcast"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
     return new NcclBroadcast<T>(opBuilder.build());
@@ -70,7 +69,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5818d38a4f0..4b052fc268b 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
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -43,7 +42,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class NcclReduce<T extends Tensor & TNumber> extends RawOp 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.
@@ -54,9 +53,9 @@ public final class NcclReduce<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of NcclReduce
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> NcclReduce<T> create(Scope scope, Iterable<Operand<T>> input, String reduction) {
+  public static <T extends TNumber> NcclReduce<T> create(Scope scope, Iterable<Operand<T>> input, String reduction) {
     OperationBuilder opBuilder = scope.env().opBuilder("NcclReduce", scope.makeOpName("NcclReduce"));
-    opBuilder.addInputList(Operands.asOutputs(input));
+    opBuilder.addInputList(Operands.asOutputs(scope, input));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("reduction", reduction);
     return new NcclReduce<T>(opBuilder.build());
@@ -69,7 +68,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 94777054bce..a45c79cb0c8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Makes its input available to the next iteration.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class NextIteration<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class NextIteration<T extends Tensor> extends RawOp implements Oper
    * @return a new instance of NextIteration
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> NextIteration<T> create(Scope scope, Operand<T> data) {
+  public static <T extends TType> NextIteration<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("NextIteration", scope.makeOpName("NextIteration"));
-    opBuilder.addInput(data.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new NextIteration<T>(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 fd18a3f6a49..da0d820f8c3 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a one-hot tensor.
@@ -116,7 +116,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class OneHot<U extends Tensor> extends RawOp implements Operand<U> {
+public final class OneHot<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OneHot}
@@ -149,12 +149,12 @@ private Options() {
    * @return a new instance of OneHot
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> OneHot<U> create(Scope scope, Operand<T> indices, Operand<TInt32> depth, Operand<U> onValue, Operand<U> offValue, Options... options) {
+  public static <U extends TType, T extends TNumber> OneHot<U> create(Scope scope, Operand<T> indices, Operand<TInt32> depth, Operand<U> onValue, Operand<U> offValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OneHot", scope.makeOpName("OneHot"));
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(depth.asOutput());
-    opBuilder.addInput(onValue.asOutput());
-    opBuilder.addInput(offValue.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(depth.asOutput(scope));
+    opBuilder.addInput(onValue.asOutput(scope));
+    opBuilder.addInput(offValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -181,7 +181,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 c1228b8cb27..71f7365ac05 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a tensor of ones with the same shape and type as x.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class OnesLike<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class OnesLike<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of OnesLike
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> OnesLike<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> OnesLike<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("OnesLike", scope.makeOpName("OnesLike"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new OnesLike<T>(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 9ae3fd09642..a408ef2780f 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
@@ -152,7 +152,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 91c92d7bc80..0402c281e1e 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Op peeks at the values at the specified key.  If the
@@ -41,7 +41,7 @@
  * performance.
  */
 @Operator
-public final class OrderedMapPeek extends RawOp implements Iterable<Operand<Tensor>> {
+public final class OrderedMapPeek extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapPeek}
@@ -102,8 +102,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static OrderedMapPeek create(Scope scope, Operand<TInt64> key, Operand<TInt32> indices, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OrderedMapPeek", scope.makeOpName("OrderedMapPeek"));
-    opBuilder.addInput(key.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(key.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
@@ -165,7 +165,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 d16383393f4..3579f28aa11 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
@@ -152,7 +152,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 c752a0dd84e..1d5e66552d8 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
@@ -101,9 +101,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static OrderedMapStage create(Scope scope, Operand<TInt64> key, Operand<TInt32> indices, Iterable<Operand<?>> values, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OrderedMapStage", scope.makeOpName("OrderedMapStage"));
-    opBuilder.addInput(key.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(values));
+    opBuilder.addInput(key.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
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 76f6eb79913..70b2e7c569a 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,13 +25,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Op removes and returns the values associated with the key
@@ -40,7 +40,7 @@
  * does not contain this key, the op will block until it does.
  */
 @Operator
-public final class OrderedMapUnstage extends RawOp implements Iterable<Operand<Tensor>> {
+public final class OrderedMapUnstage extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.OrderedMapUnstage}
@@ -101,8 +101,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static OrderedMapUnstage create(Scope scope, Operand<TInt64> key, Operand<TInt32> indices, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OrderedMapUnstage", scope.makeOpName("OrderedMapUnstage"));
-    opBuilder.addInput(key.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(key.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
@@ -164,7 +164,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 d0fa6beea68..57982014c0d 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
@@ -98,7 +98,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static OrderedMapUnstageNoKey create(Scope scope, Operand<TInt32> indices, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OrderedMapUnstageNoKey", scope.makeOpName("OrderedMapUnstageNoKey"));
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
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 b5f58cb90f2..d7343a5b940 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Pads a tensor.
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Pad<T extends Tensor> extends RawOp 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.
@@ -71,11 +71,11 @@ public final class Pad<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Pad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Operand<T> constantValues) {
+  public static <T extends TType, U extends TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Operand<T> constantValues) {
     OperationBuilder opBuilder = scope.env().opBuilder("PadV2", scope.makeOpName("Pad"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(paddings.asOutput());
-    opBuilder.addInput(constantValues.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(paddings.asOutput(scope));
+    opBuilder.addInput(constantValues.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Pad<T>(opBuilder.build());
   }
@@ -87,7 +87,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 0e81d3f30cb..a94dce2409d 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates a list of `N` tensors along the first dimension.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ParallelConcat<T extends Tensor> extends RawOp 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.
@@ -63,9 +63,9 @@ public final class ParallelConcat<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of ParallelConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ParallelConcat<T> create(Scope scope, Iterable<Operand<T>> values, Shape shape) {
+  public static <T extends TType> ParallelConcat<T> create(Scope scope, Iterable<Operand<T>> values, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParallelConcat", scope.makeOpName("ParallelConcat"));
-    opBuilder.addInputList(Operands.asOutputs(values));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
     return new ParallelConcat<T>(opBuilder.build());
@@ -79,7 +79,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 de681532c08..b0b9c50b30e 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Interleave the values from the `data` tensors into a single tensor.
@@ -89,7 +89,7 @@
  * @param <T> data type for {@code merged()} output
  */
 @Operator
-public final class ParallelDynamicStitch<T extends Tensor> extends RawOp 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.
@@ -100,10 +100,10 @@ public final class ParallelDynamicStitch<T extends Tensor> extends RawOp impleme
    * @return a new instance of ParallelDynamicStitch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ParallelDynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
+  public static <T extends TType> ParallelDynamicStitch<T> create(Scope scope, Iterable<Operand<TInt32>> indices, Iterable<Operand<T>> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParallelDynamicStitch", scope.makeOpName("ParallelDynamicStitch"));
-    opBuilder.addInputList(Operands.asOutputs(indices));
-    opBuilder.addInputList(Operands.asOutputs(data));
+    opBuilder.addInputList(Operands.asOutputs(scope, indices));
+    opBuilder.addInputList(Operands.asOutputs(scope, data));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ParallelDynamicStitch<T>(opBuilder.build());
   }
@@ -115,7 +115,7 @@ public Output<T> merged() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return merged;
   }
   
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 2a4b3c6dbd1..f32043f33e8 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A placeholder op for a value that will be fed into the computation.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Placeholder<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Placeholder<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Placeholder}
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of Placeholder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Placeholder<T> create(Scope scope, DataType<T> dtype, Options... options) {
+  public static <T extends TType> Placeholder<T> create(Scope scope, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Placeholder", scope.makeOpName("Placeholder"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -100,7 +100,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 77e27ad510a..a4c27af09dd 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A placeholder op that passes through `input` when its output is not fed.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class PlaceholderWithDefault<T extends Tensor> extends RawOp 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.
@@ -45,9 +45,9 @@ public final class PlaceholderWithDefault<T extends Tensor> extends RawOp implem
    * @return a new instance of PlaceholderWithDefault
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> PlaceholderWithDefault<T> create(Scope scope, Operand<T> input, Shape shape) {
+  public static <T extends TType> PlaceholderWithDefault<T> create(Scope scope, Operand<T> input, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("PlaceholderWithDefault", scope.makeOpName("PlaceholderWithDefault"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
     return new PlaceholderWithDefault<T>(opBuilder.build());
@@ -61,7 +61,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 1f341e11de5..5b0feeee10c 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
@@ -73,7 +73,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Print create(Scope scope, Operand<TString> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("PrintV2", scope.makeOpName("Print"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 2b112ea7512..c2310032f0e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Prod<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Prod<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Prod}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of Prod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Prod<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> Prod<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Prod", scope.makeOpName("Prod"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 b2cfe0f375c..24bfb366f82 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reshapes a quantized tensor as per the Reshape op.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class QuantizedReshape<T extends Tensor> extends RawOp {
+public final class QuantizedReshape<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedReshape operation.
@@ -50,12 +50,12 @@ public final class QuantizedReshape<T extends Tensor> extends RawOp {
    * @return a new instance of QuantizedReshape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> QuantizedReshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
+  public static <T extends TType, U extends TNumber> QuantizedReshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedReshape", scope.makeOpName("QuantizedReshape"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(inputMin.asOutput());
-    opBuilder.addInput(inputMax.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(inputMin.asOutput(scope));
+    opBuilder.addInput(inputMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new QuantizedReshape<T>(opBuilder.build());
   }
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 6c3adb418c5..b843c8d0347 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -46,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Range<T extends Tensor & TNumber> extends RawOp 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.
@@ -58,11 +57,11 @@ public final class Range<T extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Range
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Range<T> create(Scope scope, Operand<T> start, Operand<T> limit, Operand<T> delta) {
+  public static <T extends TNumber> Range<T> create(Scope scope, Operand<T> start, Operand<T> limit, Operand<T> delta) {
     OperationBuilder opBuilder = scope.env().opBuilder("Range", scope.makeOpName("Range"));
-    opBuilder.addInput(start.asOutput());
-    opBuilder.addInput(limit.asOutput());
-    opBuilder.addInput(delta.asOutput());
+    opBuilder.addInput(start.asOutput(scope));
+    opBuilder.addInput(limit.asOutput(scope));
+    opBuilder.addInput(delta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Range<T>(opBuilder.build());
   }
@@ -75,7 +74,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 267121e42b5..5f7f0d8bb09 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the rank of a tensor.
@@ -54,9 +54,9 @@ public final class Rank extends RawOp implements Operand<TInt32> {
    * @return a new instance of Rank
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Rank create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Rank create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Rank", scope.makeOpName("Rank"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Rank(opBuilder.build());
   }
@@ -68,7 +68,7 @@ public Output<TInt32> output() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return output;
   }
   
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 c7657c29093..a8eb8abbcf1 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reads the value of a variable.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class ReadVariableOp<T extends Tensor> extends RawOp 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.
@@ -52,9 +52,9 @@ public final class ReadVariableOp<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of ReadVariableOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ReadVariableOp<T> create(Scope scope, Operand<?> resource, DataType<T> dtype) {
+  public static <T extends TType> ReadVariableOp<T> create(Scope scope, Operand<?> resource, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReadVariableOp", scope.makeOpName("ReadVariableOp"));
-    opBuilder.addInput(resource.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new ReadVariableOp<T>(opBuilder.build());
@@ -67,7 +67,7 @@ public Output<T> value() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return value;
   }
   
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 9a3daab0e35..e1ac23f5aba 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Receives the named tensor from send_device on recv_device.
  * 
  * @param <T> data type for {@code tensor()} output
  */
-public final class Recv<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Recv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Recv}
@@ -70,7 +70,7 @@ private Options() {
    * @return a new instance of Recv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Recv<T> create(Scope scope, DataType<T> tensorType, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
+  public static <T extends TType> Recv<T> create(Scope scope, DataType<T> tensorType, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Recv", scope.makeOpName("Recv"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("tensor_type", tensorType);
@@ -106,7 +106,7 @@ public Output<T> tensor() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return tensor;
   }
   
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 ce419d834ce..356ab230b44 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -70,10 +69,10 @@ private Options() {
    * @return a new instance of ReduceAll
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ReduceAll create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends TNumber> ReduceAll create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("All", scope.makeOpName("ReduceAll"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +99,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 b981ee64c90..97ca39bec67 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -70,10 +69,10 @@ private Options() {
    * @return a new instance of ReduceAny
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ReduceAny create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
+  public static <T extends TNumber> ReduceAny create(Scope scope, Operand<TBool> input, Operand<T> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Any", scope.makeOpName("ReduceAny"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +99,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 5cfd7649a83..f39b1d2d30f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the maximum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceMax<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ReduceMax<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceMax}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of ReduceMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ReduceMax<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> ReduceMax<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Max", scope.makeOpName("ReduceMax"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 52390a5fe61..ec838d15a3f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the minimum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceMin<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ReduceMin<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceMin}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of ReduceMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ReduceMin<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> ReduceMin<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Min", scope.makeOpName("ReduceMin"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 907ef7df4aa..1595f26edbc 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceProd<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ReduceProd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceProd}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of ReduceProd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ReduceProd<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> ReduceProd<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Prod", scope.makeOpName("ReduceProd"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 321403d3139..55bd4428494 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReduceSum<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ReduceSum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReduceSum}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of ReduceSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ReduceSum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> ReduceSum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sum", scope.makeOpName("ReduceSum"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5dc409e4194..7bbe531842c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates or finds a child frame, and makes `data` available to the child frame.
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefEnter<T extends Tensor> extends RawOp implements Operand<T> {
+public final class RefEnter<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.RefEnter}
@@ -77,9 +77,9 @@ private Options() {
    * @return a new instance of RefEnter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RefEnter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
+  public static <T extends TType> RefEnter<T> create(Scope scope, Operand<T> data, String frameName, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefEnter", scope.makeOpName("RefEnter"));
-    opBuilder.addInput(data.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("frame_name", frameName);
     if (options != null) {
@@ -117,7 +117,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 0ea9df5491c..d4a0d014fb1 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Exits the current frame to its parent frame.
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefExit<T extends Tensor> extends RawOp 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.
@@ -44,9 +44,9 @@ public final class RefExit<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of RefExit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RefExit<T> create(Scope scope, Operand<T> data) {
+  public static <T extends TType> RefExit<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefExit", scope.makeOpName("RefExit"));
-    opBuilder.addInput(data.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RefExit<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a61c3af6c38..6e281e94100 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Return the same ref tensor as the input ref tensor.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefIdentity<T extends Tensor> extends RawOp 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.
@@ -42,9 +42,9 @@ public final class RefIdentity<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of RefIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RefIdentity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> RefIdentity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefIdentity", scope.makeOpName("RefIdentity"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RefIdentity<T>(opBuilder.build());
   }
@@ -56,7 +56,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 4bef835d1dd..ee8caf89364 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the value of an available tensor from `inputs` to `output`.
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RefMerge<T extends Tensor> extends RawOp {
+public final class RefMerge<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RefMerge operation.
@@ -50,9 +50,9 @@ public final class RefMerge<T extends Tensor> extends RawOp {
    * @return a new instance of RefMerge
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RefMerge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
+  public static <T extends TType> RefMerge<T> create(Scope scope, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefMerge", scope.makeOpName("RefMerge"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RefMerge<T>(opBuilder.build());
   }
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 44db5220a8b..26d45692767 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Makes its input available to the next iteration.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class RefNextIteration<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class RefNextIteration<T extends Tensor> extends RawOp implements O
    * @return a new instance of RefNextIteration
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RefNextIteration<T> create(Scope scope, Operand<T> data) {
+  public static <T extends TType> RefNextIteration<T> create(Scope scope, Operand<T> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefNextIteration", scope.makeOpName("RefNextIteration"));
-    opBuilder.addInput(data.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RefNextIteration<T>(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 4965058bdb5..90ddf899dca 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the `index`th element of `inputs` to `output`.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class RefSelect<T extends Tensor> extends RawOp 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.
@@ -46,10 +46,10 @@ public final class RefSelect<T extends Tensor> extends RawOp implements Operand<
    * @return a new instance of RefSelect
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RefSelect<T> create(Scope scope, Operand<TInt32> index, Iterable<Operand<T>> inputs) {
+  public static <T extends TType> RefSelect<T> create(Scope scope, Operand<TInt32> index, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefSelect", scope.makeOpName("RefSelect"));
-    opBuilder.addInput(index.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInput(index.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RefSelect<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 2222f840dfb..4b1218bdc53 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * Forwards the ref tensor `data` to the output port determined by `pred`.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code outputFalse()} output
  */
 @Operator
-public final class RefSwitch<T extends Tensor> extends RawOp {
+public final class RefSwitch<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RefSwitch operation.
@@ -50,10 +50,10 @@ public final class RefSwitch<T extends Tensor> extends RawOp {
    * @return a new instance of RefSwitch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RefSwitch<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
+  public static <T extends TType> RefSwitch<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
     OperationBuilder opBuilder = scope.env().opBuilder("RefSwitch", scope.makeOpName("RefSwitch"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(pred.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(pred.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RefSwitch<T>(opBuilder.build());
   }
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 53bcdfbe149..b474c5b1f4e 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
@@ -25,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Execute a sub graph on a remote processor.
@@ -44,7 +44,7 @@
  * will be passed to consumer nodes as outputs of this node.
  */
 @Operator
-public final class RemoteFusedGraphExecute extends RawOp implements Iterable<Operand<Tensor>> {
+public final class RemoteFusedGraphExecute extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new RemoteFusedGraphExecute operation.
@@ -59,7 +59,7 @@ public final class RemoteFusedGraphExecute extends RawOp implements Iterable<Ope
   @Endpoint(describeByClass = true)
   public static RemoteFusedGraphExecute create(Scope scope, Iterable<Operand<?>> inputs, List<DataType<?>> Toutputs, String serializedRemoteFusedGraphExecuteInfo) {
     OperationBuilder opBuilder = scope.env().opBuilder("RemoteFusedGraphExecute", scope.makeOpName("RemoteFusedGraphExecute"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] ToutputsArray = new DataType[Toutputs.size()];
     for (int i = 0; i < ToutputsArray.length; ++i) {
@@ -79,7 +79,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 865678a03c3..ccfa83a761a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reshapes a tensor.
@@ -94,7 +94,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Reshape<T extends Tensor> extends RawOp 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.
@@ -105,10 +105,10 @@ public final class Reshape<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Reshape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Reshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape) {
+  public static <T extends TType, U extends TNumber> Reshape<T> create(Scope scope, Operand<T> tensor, Operand<U> shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("Reshape", scope.makeOpName("Reshape"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Reshape<T>(opBuilder.build());
   }
@@ -120,7 +120,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 91ae06f106b..21252c85ac4 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ResourceCountUpTo<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,9 +47,9 @@ public final class ResourceCountUpTo<T extends Tensor & TNumber> extends RawOp i
    * @return a new instance of ResourceCountUpTo
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResourceCountUpTo<T> create(Scope scope, Operand<?> resource, Long limit, DataType<T> T) {
+  public static <T extends TNumber> ResourceCountUpTo<T> create(Scope scope, Operand<?> resource, Long limit, DataType<T> T) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceCountUpTo", scope.makeOpName("ResourceCountUpTo"));
-    opBuilder.addInput(resource.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("limit", limit);
     opBuilder.setAttr("T", T);
@@ -66,7 +65,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5078574b732..eff124ec0a6 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gather slices from the variable pointed to by `resource` according to `indices`.
@@ -49,7 +49,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ResourceGather<U extends Tensor> extends RawOp implements Operand<U> {
+public final class ResourceGather<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ResourceGather}
@@ -90,10 +90,10 @@ private Options() {
    * @return a new instance of ResourceGather
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> ResourceGather<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype, Options... options) {
+  public static <U extends TType, T extends TNumber> ResourceGather<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceGather", scope.makeOpName("ResourceGather"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -130,7 +130,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 9ae8c96b1e6..5b192243f66 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ResourceGatherNd<U extends Tensor> extends RawOp 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.
@@ -45,10 +45,10 @@ public final class ResourceGatherNd<U extends Tensor> extends RawOp implements O
    * @return a new instance of ResourceGatherNd
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> ResourceGatherNd<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype) {
+  public static <U extends TType, T extends TNumber> ResourceGatherNd<U> create(Scope scope, Operand<?> resource, Operand<T> indices, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceGatherNd", scope.makeOpName("ResourceGatherNd"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new ResourceGatherNd<U>(opBuilder.build());
@@ -61,7 +61,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 61956f29edc..bd595ce39c9 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds sparse updates to the variable referenced by `resource`.
@@ -63,11 +63,11 @@ public final class ResourceScatterAdd extends RawOp {
    * @return a new instance of ResourceScatterAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterAdd create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends TNumber, U extends TType> ResourceScatterAdd create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterAdd", scope.makeOpName("ResourceScatterAdd"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceScatterAdd(opBuilder.build());
   }
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 72e7f964556..616a3bcac77 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Divides sparse updates into the variable referenced by `resource`.
@@ -63,11 +63,11 @@ public final class ResourceScatterDiv extends RawOp {
    * @return a new instance of ResourceScatterDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterDiv create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends TNumber, U extends TType> ResourceScatterDiv create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterDiv", scope.makeOpName("ResourceScatterDiv"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceScatterDiv(opBuilder.build());
   }
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 97ba2bc7ba3..50c2140dde2 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
@@ -63,11 +63,11 @@ public final class ResourceScatterMax extends RawOp {
    * @return a new instance of ResourceScatterMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMax create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends TNumber, U extends TType> ResourceScatterMax create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterMax", scope.makeOpName("ResourceScatterMax"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceScatterMax(opBuilder.build());
   }
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 724625509a2..8195d72d646 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
@@ -63,11 +63,11 @@ public final class ResourceScatterMin extends RawOp {
    * @return a new instance of ResourceScatterMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMin create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends TNumber, U extends TType> ResourceScatterMin create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterMin", scope.makeOpName("ResourceScatterMin"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceScatterMin(opBuilder.build());
   }
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 6955a530fdf..077955dd6bc 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Multiplies sparse updates into the variable referenced by `resource`.
@@ -63,11 +63,11 @@ public final class ResourceScatterMul extends RawOp {
    * @return a new instance of ResourceScatterMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterMul create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends TNumber, U extends TType> ResourceScatterMul create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterMul", scope.makeOpName("ResourceScatterMul"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceScatterMul(opBuilder.build());
   }
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 ba9aeb61d67..571b7a94bb9 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse addition to individual values or slices in a Variable.
@@ -97,11 +97,11 @@ private Options() {
    * @return a new instance of ResourceScatterNdAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdAdd create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
+  public static <T extends TNumber, U extends TType> ResourceScatterNdAdd create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterNdAdd", scope.makeOpName("ResourceScatterNdAdd"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 68ae77e652a..6462a1049e8 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse subtraction to individual values or slices in a Variable.
@@ -97,11 +97,11 @@ private Options() {
    * @return a new instance of ResourceScatterNdSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdSub create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
+  public static <T extends TNumber, U extends TType> ResourceScatterNdSub create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterNdSub", scope.makeOpName("ResourceScatterNdSub"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 39ba65073a5..3938402a8a9 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse `updates` to individual values or slices within a given
@@ -99,11 +99,11 @@ private Options() {
    * @return a new instance of ResourceScatterNdUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterNdUpdate create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
+  public static <T extends TNumber, U extends TType> ResourceScatterNdUpdate create(Scope scope, Operand<?> ref, Operand<T> indices, Operand<U> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterNdUpdate", scope.makeOpName("ResourceScatterNdUpdate"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 c750a7965d2..c95d8015e40 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts sparse updates from the variable referenced by `resource`.
@@ -63,11 +63,11 @@ public final class ResourceScatterSub extends RawOp {
    * @return a new instance of ResourceScatterSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterSub create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends TNumber, U extends TType> ResourceScatterSub create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterSub", scope.makeOpName("ResourceScatterSub"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceScatterSub(opBuilder.build());
   }
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 0d20631c227..80613d7850f 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Assigns sparse updates to the variable referenced by `resource`.
@@ -54,11 +54,11 @@ public final class ResourceScatterUpdate extends RawOp {
    * @return a new instance of ResourceScatterUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceScatterUpdate create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
+  public static <T extends TNumber, U extends TType> ResourceScatterUpdate create(Scope scope, Operand<?> resource, Operand<T> indices, Operand<U> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceScatterUpdate", scope.makeOpName("ResourceScatterUpdate"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceScatterUpdate(opBuilder.build());
   }
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 ee79039e54e..8987ccb0afa 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Assign `value` to the sliced l-value reference of `ref`.
@@ -108,13 +108,13 @@ private Options() {
    * @return a new instance of ResourceStridedSliceAssign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> ResourceStridedSliceAssign create(Scope scope, Operand<?> ref, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> value, Options... options) {
+  public static <T extends TNumber, U extends TType> ResourceStridedSliceAssign create(Scope scope, Operand<?> ref, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceStridedSliceAssign", scope.makeOpName("ResourceStridedSliceAssign"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(begin.asOutput());
-    opBuilder.addInput(end.asOutput());
-    opBuilder.addInput(strides.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(begin.asOutput(scope));
+    opBuilder.addInput(end.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 d604d5e1335..6a4ea9c4731 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reverses specific dimensions of a tensor.
@@ -81,7 +81,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Reverse<T extends Tensor> extends RawOp 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.
@@ -93,10 +93,10 @@ public final class Reverse<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Reverse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Reverse<T> create(Scope scope, Operand<T> tensor, Operand<U> axis) {
+  public static <T extends TType, U extends TNumber> Reverse<T> create(Scope scope, Operand<T> tensor, Operand<U> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReverseV2", scope.makeOpName("Reverse"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Reverse<T>(opBuilder.build());
   }
@@ -109,7 +109,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 6e54f87fa71..b74c988479a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reverses variable length slices.
@@ -87,7 +87,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ReverseSequence<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ReverseSequence<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ReverseSequence}
@@ -120,10 +120,10 @@ private Options() {
    * @return a new instance of ReverseSequence
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ReverseSequence<T> create(Scope scope, Operand<T> input, Operand<U> seqLengths, Long seqDim, Options... options) {
+  public static <T extends TType, U extends TNumber> ReverseSequence<T> create(Scope scope, Operand<T> input, Operand<U> seqLengths, Long seqDim, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReverseSequence", scope.makeOpName("ReverseSequence"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(seqLengths.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(seqLengths.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("seq_dim", seqDim);
     if (options != null) {
@@ -151,7 +151,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 d63e80712df..26fe13130e8 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Rolls the elements of a tensor along an axis.
@@ -55,7 +55,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Roll<T extends Tensor> extends RawOp 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.
@@ -73,11 +73,11 @@ public final class Roll<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Roll
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> Roll<T> create(Scope scope, Operand<T> input, Operand<U> shift, Operand<V> axis) {
+  public static <T extends TType, U extends TNumber, V extends TNumber> Roll<T> create(Scope scope, Operand<T> input, Operand<U> shift, Operand<V> axis) {
     OperationBuilder opBuilder = scope.env().opBuilder("Roll", scope.makeOpName("Roll"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(shift.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(shift.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Roll<T>(opBuilder.build());
   }
@@ -92,7 +92,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 2d753afec51..9e5261a29fe 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
@@ -138,9 +138,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Rpc create(Scope scope, Operand<TString> address, Operand<TString> method, Operand<TString> request, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Rpc", scope.makeOpName("Rpc"));
-    opBuilder.addInput(address.asOutput());
-    opBuilder.addInput(method.asOutput());
-    opBuilder.addInput(request.asOutput());
+    opBuilder.addInput(address.asOutput(scope));
+    opBuilder.addInput(method.asOutput(scope));
+    opBuilder.addInput(request.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -192,7 +192,7 @@ public Output<TString> response() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return response;
   }
   
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 e199025abe1..cbff38eccdf 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds sparse updates to a variable reference.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterAdd<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterAdd}
@@ -90,11 +90,11 @@ private Options() {
    * @return a new instance of ScatterAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterAdd", scope.makeOpName("ScatterAdd"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -123,7 +123,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 35f0cd4cfdb..b5e55e43461 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Divides a variable reference by sparse updates.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterDiv<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterDiv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterDiv}
@@ -86,11 +86,11 @@ private Options() {
    * @return a new instance of ScatterDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterDiv<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterDiv<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterDiv", scope.makeOpName("ScatterDiv"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -119,7 +119,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 03b68727112..be6e2af9a31 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -57,7 +56,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ScatterMax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMax}
@@ -90,11 +89,11 @@ private Options() {
    * @return a new instance of ScatterMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMax<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TNumber, U extends TNumber> ScatterMax<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterMax", scope.makeOpName("ScatterMax"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -123,7 +122,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 16538a5e7d3..4c8ffa1cd07 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -57,7 +56,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMin<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ScatterMin<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMin}
@@ -90,11 +89,11 @@ private Options() {
    * @return a new instance of ScatterMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> ScatterMin<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TNumber, U extends TNumber> ScatterMin<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterMin", scope.makeOpName("ScatterMin"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -123,7 +122,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 dba113e4dfe..c27d4718bcd 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Multiplies sparse updates into a variable reference.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterMul<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterMul}
@@ -86,11 +86,11 @@ private Options() {
    * @return a new instance of ScatterMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterMul<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterMul<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterMul", scope.makeOpName("ScatterMul"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -119,7 +119,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 2081ee76b11..24a23bf8883 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Scatter `updates` into a new tensor according to `indices`.
@@ -111,7 +111,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ScatterNd<U extends Tensor> extends RawOp 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.
@@ -123,11 +123,11 @@ public final class ScatterNd<U extends Tensor> extends RawOp implements Operand<
    * @return a new instance of ScatterNd
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> ScatterNd<U> create(Scope scope, Operand<T> indices, Operand<U> updates, Operand<T> shape) {
+  public static <U extends TType, T extends TNumber> ScatterNd<U> create(Scope scope, Operand<T> indices, Operand<U> updates, Operand<T> shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNd", scope.makeOpName("ScatterNd"));
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ScatterNd<U>(opBuilder.build());
   }
@@ -141,7 +141,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 15f1c663382..ba73d6d3318 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse addition to individual values or slices in a Variable.
@@ -64,7 +64,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdAdd<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterNdAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdAdd}
@@ -100,11 +100,11 @@ private Options() {
    * @return a new instance of ScatterNdAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterNdAdd<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdAdd", scope.makeOpName("ScatterNdAdd"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -134,7 +134,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 65a20f09626..91967219b75 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse addition to `input` using individual values or slices
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class ScatterNdNonAliasingAdd<T extends Tensor> extends RawOp 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.
@@ -82,11 +82,11 @@ public final class ScatterNdNonAliasingAdd<T extends Tensor> extends RawOp imple
    * @return a new instance of ScatterNdNonAliasingAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdNonAliasingAdd<T> create(Scope scope, Operand<T> input, Operand<U> indices, Operand<T> updates) {
+  public static <T extends TType, U extends TNumber> ScatterNdNonAliasingAdd<T> create(Scope scope, Operand<T> input, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdNonAliasingAdd", scope.makeOpName("ScatterNdNonAliasingAdd"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ScatterNdNonAliasingAdd<T>(opBuilder.build());
   }
@@ -100,7 +100,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a83f24ca7b4..fa11f76c173 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse subtraction to individual values or slices in a Variable.
@@ -66,7 +66,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdSub<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterNdSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdSub}
@@ -102,11 +102,11 @@ private Options() {
    * @return a new instance of ScatterNdSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterNdSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdSub", scope.makeOpName("ScatterNdSub"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -136,7 +136,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 6b8cfd70bd1..7ca30617491 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse `updates` to individual values or slices within a given
@@ -68,7 +68,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterNdUpdate<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterNdUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterNdUpdate}
@@ -104,11 +104,11 @@ private Options() {
    * @return a new instance of ScatterNdUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterNdUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterNdUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterNdUpdate", scope.makeOpName("ScatterNdUpdate"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -138,7 +138,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 3c3c8651b00..7c6ddabdc2e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts sparse updates to a variable reference.
@@ -56,7 +56,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterSub<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterSub<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterSub}
@@ -89,11 +89,11 @@ private Options() {
    * @return a new instance of ScatterSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterSub<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterSub", scope.makeOpName("ScatterSub"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -122,7 +122,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 d14bf7554af..2f51aeab5fa 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies sparse updates to a variable reference.
@@ -60,7 +60,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class ScatterUpdate<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ScatterUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.ScatterUpdate}
@@ -93,11 +93,11 @@ private Options() {
    * @return a new instance of ScatterUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ScatterUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
+  public static <T extends TType, U extends TNumber> ScatterUpdate<T> create(Scope scope, Operand<T> ref, Operand<U> indices, Operand<T> updates, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScatterUpdate", scope.makeOpName("ScatterUpdate"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -126,7 +126,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 c0b5b3ccf79..5dced3f7e92 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Select<T extends Tensor> extends RawOp 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.
@@ -44,11 +44,11 @@ public final class Select<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Select
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Select<T> create(Scope scope, Operand<TBool> condition, Operand<T> t, Operand<T> e) {
+  public static <T extends TType> Select<T> create(Scope scope, Operand<TBool> condition, Operand<T> t, Operand<T> e) {
     OperationBuilder opBuilder = scope.env().opBuilder("SelectV2", scope.makeOpName("Select"));
-    opBuilder.addInput(condition.asOutput());
-    opBuilder.addInput(t.asOutput());
-    opBuilder.addInput(e.asOutput());
+    opBuilder.addInput(condition.asOutput(scope));
+    opBuilder.addInput(t.asOutput(scope));
+    opBuilder.addInput(e.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Select<T>(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 9376e4ebed4..4887e672356 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sends the named tensor from send_device to recv_device.
@@ -66,9 +66,9 @@ private Options() {
    * @return a new instance of Send
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Send create(Scope scope, Operand<T> tensor, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
+  public static <T extends TType> Send create(Scope scope, Operand<T> tensor, String tensorName, String sendDevice, Long sendDeviceIncarnation, String recvDevice, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Send", scope.makeOpName("Send"));
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("tensor_name", tensorName);
     opBuilder.setAttr("send_device", sendDevice);
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 e70f0df0453..00a5e555f41 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the difference between two lists of numbers or strings.
@@ -57,7 +57,7 @@
  * @param <U> data type for {@code idx()} output
  */
 @Operator
-public final class SetDiff1d<T extends Tensor, U extends Tensor & TNumber> extends RawOp {
+public final class SetDiff1d<T extends TType, U extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SetDiff1d operation.
@@ -69,10 +69,10 @@ public final class SetDiff1d<T extends Tensor, U extends Tensor & TNumber> exten
    * @return a new instance of SetDiff1d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SetDiff1d<T, U> create(Scope scope, Operand<T> x, Operand<T> y, DataType<U> outIdx) {
+  public static <T extends TType, U extends TNumber> SetDiff1d<T, U> create(Scope scope, Operand<T> x, Operand<T> y, DataType<U> outIdx) {
     OperationBuilder opBuilder = scope.env().opBuilder("ListDiff", scope.makeOpName("SetDiff1d"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_idx", outIdx);
     return new SetDiff1d<T, U>(opBuilder.build());
@@ -87,7 +87,7 @@ public static <T extends Tensor, U extends Tensor & TNumber> SetDiff1d<T, U> cre
    * @return a new instance of SetDiff1d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SetDiff1d<T, TInt32> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> SetDiff1d<T, TInt32> create(Scope scope, Operand<T> x, Operand<T> y) {
     return create(scope, x, y, TInt32.DTYPE);
   }
   
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 106d4ebacfb..b82a4272561 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Number of unique elements along last dimension of input `set`.
@@ -72,11 +72,11 @@ private Options() {
    * @return a new instance of SetSize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SetSize create(Scope scope, Operand<TInt64> setIndices, Operand<T> setValues, Operand<TInt64> setShape, Options... options) {
+  public static <T extends TType> SetSize create(Scope scope, Operand<TInt64> setIndices, Operand<T> setValues, Operand<TInt64> setShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SetSize", scope.makeOpName("SetSize"));
-    opBuilder.addInput(setIndices.asOutput());
-    opBuilder.addInput(setValues.asOutput());
-    opBuilder.addInput(setShape.asOutput());
+    opBuilder.addInput(setIndices.asOutput(scope));
+    opBuilder.addInput(setValues.asOutput(scope));
+    opBuilder.addInput(setShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -105,7 +105,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 864b7cecb3d..921887e774b 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the shape of a tensor.
@@ -45,7 +45,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Shape<U extends Tensor & TNumber> extends RawOp 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.
@@ -56,9 +56,9 @@ public final class Shape<U extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Shape
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Shape<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
+  public static <U extends TNumber, T extends TType> Shape<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Shape", scope.makeOpName("Shape"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new Shape<U>(opBuilder.build());
@@ -72,7 +72,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Shape<U> create(Sco
    * @return a new instance of Shape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Shape<TInt32> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Shape<TInt32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
@@ -83,7 +83,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 48af1105888..3e137bf5f63 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
@@ -25,7 +25,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -33,6 +32,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns shape of tensors.
@@ -42,7 +42,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class ShapeN<U extends Tensor & TNumber> extends RawOp 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.
@@ -53,9 +53,9 @@ public final class ShapeN<U extends Tensor & TNumber> extends RawOp implements I
    * @return a new instance of ShapeN
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> ShapeN<U> create(Scope scope, Iterable<Operand<T>> input, DataType<U> outType) {
+  public static <U extends TNumber, T extends TType> ShapeN<U> create(Scope scope, Iterable<Operand<T>> input, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ShapeN", scope.makeOpName("ShapeN"));
-    opBuilder.addInputList(Operands.asOutputs(input));
+    opBuilder.addInputList(Operands.asOutputs(scope, input));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new ShapeN<U>(opBuilder.build());
@@ -69,7 +69,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> ShapeN<U> create(Sc
    * @return a new instance of ShapeN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ShapeN<TInt32> create(Scope scope, Iterable<Operand<T>> input) {
+  public static <T extends TType> ShapeN<TInt32> create(Scope scope, Iterable<Operand<T>> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
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 5439bbf551a..1eb98f4ad0a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the size of a tensor.
@@ -46,7 +46,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class Size<U extends Tensor & TNumber> extends RawOp 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.
@@ -57,9 +57,9 @@ public final class Size<U extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Size
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Size<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
+  public static <U extends TNumber, T extends TType> Size<U> create(Scope scope, Operand<T> input, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Size", scope.makeOpName("Size"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new Size<U>(opBuilder.build());
@@ -73,7 +73,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Size<U> create(Scop
    * @return a new instance of Size
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Size<TInt32> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Size<TInt32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
@@ -84,7 +84,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 60bc7e2c9b3..ce33b0fae3a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Return a slice from 'input'.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Slice<T extends Tensor> extends RawOp 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.
@@ -57,11 +57,11 @@ public final class Slice<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Slice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Slice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> size) {
+  public static <T extends TType, U extends TNumber> Slice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> size) {
     OperationBuilder opBuilder = scope.env().opBuilder("Slice", scope.makeOpName("Slice"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(begin.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(begin.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Slice<T>(opBuilder.build());
   }
@@ -73,7 +73,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5fd6a3ee2be..efac77a720b 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a copy of the input tensor.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Snapshot<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class Snapshot<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of Snapshot
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Snapshot<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Snapshot<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Snapshot", scope.makeOpName("Snapshot"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Snapshot<T>(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a0b2565e5b4..f3678adee79 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * SpaceToBatch for N-D tensors of type T.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class SpaceToBatchNd<T extends Tensor> extends RawOp 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.
@@ -147,11 +147,11 @@ public final class SpaceToBatchNd<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of SpaceToBatchNd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> SpaceToBatchNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> paddings) {
+  public static <T extends TType, U extends TNumber, V extends TNumber> SpaceToBatchNd<T> create(Scope scope, Operand<T> input, Operand<U> blockShape, Operand<V> paddings) {
     OperationBuilder opBuilder = scope.env().opBuilder("SpaceToBatchND", scope.makeOpName("SpaceToBatchNd"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(blockShape.asOutput());
-    opBuilder.addInput(paddings.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(blockShape.asOutput(scope));
+    opBuilder.addInput(paddings.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SpaceToBatchNd<T>(opBuilder.build());
   }
@@ -163,7 +163,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c35c631b53a..5607f2019cd 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,12 +24,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Splits a tensor into `num_split` tensors along one dimension.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Split<T extends Tensor> extends RawOp 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.
@@ -51,10 +51,10 @@ public final class Split<T extends Tensor> extends RawOp implements Iterable<Ope
    * @return a new instance of Split
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Split<T> create(Scope scope, Operand<TInt32> axis, Operand<T> value, Long numSplit) {
+  public static <T extends TType> Split<T> create(Scope scope, Operand<TInt32> axis, Operand<T> value, Long numSplit) {
     OperationBuilder opBuilder = scope.env().opBuilder("Split", scope.makeOpName("Split"));
-    opBuilder.addInput(axis.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(axis.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_split", numSplit);
     return new Split<T>(opBuilder.build());
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 f978edffb16..e7d7c5d4ff7 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,13 +24,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Splits a tensor into `num_split` tensors along one dimension.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class SplitV<T extends Tensor> extends RawOp 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.
@@ -54,11 +54,11 @@ public final class SplitV<T extends Tensor> extends RawOp implements Iterable<Op
    * @return a new instance of SplitV
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SplitV<T> create(Scope scope, Operand<T> value, Operand<U> sizeSplits, Operand<TInt32> axis, Long numSplit) {
+  public static <T extends TType, U extends TNumber> SplitV<T> create(Scope scope, Operand<T> value, Operand<U> sizeSplits, Operand<TInt32> axis, Long numSplit) {
     OperationBuilder opBuilder = scope.env().opBuilder("SplitV", scope.makeOpName("SplitV"));
-    opBuilder.addInput(value.asOutput());
-    opBuilder.addInput(sizeSplits.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
+    opBuilder.addInput(sizeSplits.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_split", numSplit);
     return new SplitV<T>(opBuilder.build());
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 77dfed40d17..dec4d298172 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Removes dimensions of size 1 from the shape of a tensor.
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Squeeze<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Squeeze<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Squeeze}
@@ -83,9 +83,9 @@ private Options() {
    * @return a new instance of Squeeze
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Squeeze<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> Squeeze<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Squeeze", scope.makeOpName("Squeeze"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -119,7 +119,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ff77da11585..49e183e7925 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Stack<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Stack<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Stack}
@@ -83,9 +83,9 @@ private Options() {
    * @return a new instance of Stack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Stack<T> create(Scope scope, Iterable<Operand<T>> values, Options... options) {
+  public static <T extends TType> Stack<T> create(Scope scope, Iterable<Operand<T>> values, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Pack", scope.makeOpName("Stack"));
-    opBuilder.addInputList(Operands.asOutputs(values));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -113,7 +113,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c741a3ae391..e9c6b34e880 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
@@ -96,7 +96,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Stage create(Scope scope, Iterable<Operand<?>> values, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Stage", scope.makeOpName("Stage"));
-    opBuilder.addInputList(Operands.asOutputs(values));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 01de85eca54..3eb8676e7e6 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Op peeks at the values at the specified index.  If the
@@ -40,7 +40,7 @@
  * performance.
  */
 @Operator
-public final class StagePeek extends RawOp implements Iterable<Operand<Tensor>> {
+public final class StagePeek extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StagePeek}
@@ -100,7 +100,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static StagePeek create(Scope scope, Operand<TInt32> index, List<DataType<?>> dtypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StagePeek", scope.makeOpName("StagePeek"));
-    opBuilder.addInput(index.asOutput());
+    opBuilder.addInput(index.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
@@ -162,7 +162,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 a6069a51690..8129027982a 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
@@ -152,7 +152,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 f363ba72a1b..8572768171e 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Stops gradient computation.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class StopGradient<T extends Tensor> extends RawOp 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.
@@ -68,9 +68,9 @@ public final class StopGradient<T extends Tensor> extends RawOp implements Opera
    * @return a new instance of StopGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> StopGradient<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> StopGradient<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("StopGradient", scope.makeOpName("StopGradient"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new StopGradient<T>(opBuilder.build());
   }
@@ -82,7 +82,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 b1ad2a3a836..140f42ac313 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Return a strided slice from `input`.
@@ -121,7 +121,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class StridedSlice<T extends Tensor> extends RawOp implements Operand<T> {
+public final class StridedSlice<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSlice}
@@ -214,12 +214,12 @@ private Options() {
    * @return a new instance of StridedSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> StridedSlice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Options... options) {
+  public static <T extends TType, U extends TNumber> StridedSlice<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StridedSlice", scope.makeOpName("StridedSlice"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(begin.asOutput());
-    opBuilder.addInput(end.asOutput());
-    opBuilder.addInput(strides.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(begin.asOutput(scope));
+    opBuilder.addInput(end.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -300,7 +300,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 aa83a682ccb..49750f21d9c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Assign `value` to the sliced l-value reference of `ref`.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code outputRef()} output
  */
 @Operator
-public final class StridedSliceAssign<T extends Tensor> extends RawOp implements Operand<T> {
+public final class StridedSliceAssign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSliceAssign}
@@ -111,13 +111,13 @@ private Options() {
    * @return a new instance of StridedSliceAssign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> StridedSliceAssign<T> create(Scope scope, Operand<T> ref, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
+  public static <T extends TType, U extends TNumber> StridedSliceAssign<T> create(Scope scope, Operand<T> ref, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StridedSliceAssign", scope.makeOpName("StridedSliceAssign"));
-    opBuilder.addInput(ref.asOutput());
-    opBuilder.addInput(begin.asOutput());
-    opBuilder.addInput(end.asOutput());
-    opBuilder.addInput(strides.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(ref.asOutput(scope));
+    opBuilder.addInput(begin.asOutput(scope));
+    opBuilder.addInput(end.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -183,7 +183,7 @@ public Output<T> outputRef() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputRef;
   }
   
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 355dc936a4b..4cd96b37efc 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the gradient of `StridedSlice`.
@@ -43,7 +43,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator
-public final class StridedSliceGrad<U extends Tensor> extends RawOp implements Operand<U> {
+public final class StridedSliceGrad<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.StridedSliceGrad}
@@ -113,13 +113,13 @@ private Options() {
    * @return a new instance of StridedSliceGrad
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> StridedSliceGrad<U> create(Scope scope, Operand<T> shape, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> dy, Options... options) {
+  public static <U extends TType, T extends TNumber> StridedSliceGrad<U> create(Scope scope, Operand<T> shape, Operand<T> begin, Operand<T> end, Operand<T> strides, Operand<U> dy, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StridedSliceGrad", scope.makeOpName("StridedSliceGrad"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(begin.asOutput());
-    opBuilder.addInput(end.asOutput());
-    opBuilder.addInput(strides.asOutput());
-    opBuilder.addInput(dy.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(begin.asOutput(scope));
+    opBuilder.addInput(end.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
+    opBuilder.addInput(dy.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -185,7 +185,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 dbc1ee18499..1c1568d55f7 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Sum<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Sum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Sum}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of Sum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Sum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> Sum<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sum", scope.makeOpName("Sum"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 fa4e17c270f..04e500366b9 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * Forwards `data` to the output port determined by `pred`.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code outputFalse()} output
  */
 @Operator
-public final class SwitchCond<T extends Tensor> extends RawOp {
+public final class SwitchCond<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SwitchCond operation.
@@ -50,10 +50,10 @@ public final class SwitchCond<T extends Tensor> extends RawOp {
    * @return a new instance of SwitchCond
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SwitchCond<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
+  public static <T extends TType> SwitchCond<T> create(Scope scope, Operand<T> data, Operand<TBool> pred) {
     OperationBuilder opBuilder = scope.env().opBuilder("Switch", scope.makeOpName("SwitchCond"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(pred.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(pred.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SwitchCond<T>(opBuilder.build());
   }
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 c62ae36d717..20490d1a014 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a tensor that may be mutated, but only persists within a single step.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code ref()} output
  */
 @Operator
-public final class TemporaryVariable<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TemporaryVariable<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TemporaryVariable}
@@ -82,7 +82,7 @@ private Options() {
    * @return a new instance of TemporaryVariable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TemporaryVariable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
+  public static <T extends TType> TemporaryVariable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TemporaryVariable", scope.makeOpName("TemporaryVariable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
@@ -113,7 +113,7 @@ public Output<T> ref() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return ref;
   }
   
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 ad88118114d..a8a44fe49b4 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -30,6 +29,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * An array of Tensors of given size.
@@ -116,9 +116,9 @@ private Options() {
    * @return a new instance of TensorArray
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArray create(Scope scope, Operand<TInt32> size, DataType<T> dtype, Options... options) {
+  public static <T extends TType> TensorArray create(Scope scope, Operand<TInt32> size, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayV3", scope.makeOpName("TensorArray"));
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
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 fe58e12dd65..c90d5bb4f21 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
@@ -44,7 +44,7 @@ public final class TensorArrayClose extends RawOp {
   @Endpoint(describeByClass = true)
   public static TensorArrayClose create(Scope scope, Operand<?> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayCloseV3", scope.makeOpName("TensorArrayClose"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorArrayClose(opBuilder.build());
   }
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 18cce0a1b72..ae637665e2c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -30,6 +29,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Concat the elements from the TensorArray into value `value`.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayConcat<T extends Tensor> extends RawOp {
+public final class TensorArrayConcat<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayConcat}
@@ -83,10 +83,10 @@ private Options() {
    * @return a new instance of TensorArrayConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArrayConcat<T> create(Scope scope, Operand<?> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
+  public static <T extends TType> TensorArrayConcat<T> create(Scope scope, Operand<?> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayConcatV3", scope.makeOpName("TensorArrayConcat"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
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 21b1f3dfe33..53185496cd9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -30,6 +29,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gather specific elements from the TensorArray into output `value`.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayGather<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TensorArrayGather<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayGather}
@@ -74,11 +74,11 @@ private Options() {
    * @return a new instance of TensorArrayGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArrayGather<T> create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
+  public static <T extends TType> TensorArrayGather<T> create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayGatherV3", scope.makeOpName("TensorArrayGather"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -109,7 +109,7 @@ public Output<T> value() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return value;
   }
   
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 a4cf654bdcc..f701ce717e3 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
@@ -83,8 +83,8 @@ public final class TensorArrayGrad extends RawOp {
   @Endpoint(describeByClass = true)
   public static TensorArrayGrad create(Scope scope, Operand<?> handle, Operand<TFloat32> flowIn, String source) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayGradV3", scope.makeOpName("TensorArrayGrad"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("source", source);
     return new TensorArrayGrad(opBuilder.build());
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 7ffbc95fac5..17c53872bee 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
@@ -55,9 +55,9 @@ public final class TensorArrayGradWithShape extends RawOp {
   @Endpoint(describeByClass = true)
   public static TensorArrayGradWithShape create(Scope scope, Operand<?> handle, Operand<TFloat32> flowIn, Operand<TInt32> shapeToPrepend, String source) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayGradWithShape", scope.makeOpName("TensorArrayGradWithShape"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
-    opBuilder.addInput(shapeToPrepend.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
+    opBuilder.addInput(shapeToPrepend.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("source", source);
     return new TensorArrayGradWithShape(opBuilder.build());
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 c9e8ad7b98c..bea95b5d862 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -30,12 +29,13 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayPack<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TensorArrayPack<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorArrayPack}
@@ -67,10 +67,10 @@ private Options() {
    * @return a new instance of TensorArrayPack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArrayPack<T> create(Scope scope, Operand<TString> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
+  public static <T extends TType> TensorArrayPack<T> create(Scope scope, Operand<TString> handle, Operand<TFloat32> flowIn, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayPack", scope.makeOpName("TensorArrayPack"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -97,7 +97,7 @@ public Output<T> value() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return value;
   }
   
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 55148e3a208..332093b8d88 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Read an element from the TensorArray into output `value`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code value()} output
  */
 @Operator
-public final class TensorArrayRead<T extends Tensor> extends RawOp 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.
@@ -49,11 +49,11 @@ public final class TensorArrayRead<T extends Tensor> extends RawOp implements Op
    * @return a new instance of TensorArrayRead
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArrayRead<T> create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<TFloat32> flowIn, DataType<T> dtype) {
+  public static <T extends TType> TensorArrayRead<T> create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<TFloat32> flowIn, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayReadV3", scope.makeOpName("TensorArrayRead"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(index.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new TensorArrayRead<T>(opBuilder.build());
@@ -67,7 +67,7 @@ public Output<T> value() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return value;
   }
   
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 b4f7e3262a2..56633a97ddb 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Scatter the data from the input value into specific TensorArray elements.
@@ -48,12 +48,12 @@ public final class TensorArrayScatter extends RawOp implements Operand<TFloat32>
    * @return a new instance of TensorArrayScatter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArrayScatter create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<T> value, Operand<TFloat32> flowIn) {
+  public static <T extends TType> TensorArrayScatter create(Scope scope, Operand<?> handle, Operand<TInt32> indices, Operand<T> value, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayScatterV3", scope.makeOpName("TensorArrayScatter"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(value.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorArrayScatter(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<TFloat32> flowOut() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return flowOut;
   }
   
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 89642346996..4cc2cd541af 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
@@ -45,8 +45,8 @@ public final class TensorArraySize extends RawOp implements Operand<TInt32> {
   @Endpoint(describeByClass = true)
   public static TensorArraySize create(Scope scope, Operand<?> handle, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArraySizeV3", scope.makeOpName("TensorArraySize"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorArraySize(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 7e46420e331..fe3332e4e42 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Split the data from the input value into TensorArray elements.
@@ -69,12 +69,12 @@ public final class TensorArraySplit extends RawOp implements Operand<TFloat32> {
    * @return a new instance of TensorArraySplit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArraySplit create(Scope scope, Operand<?> handle, Operand<T> value, Operand<TInt64> lengths, Operand<TFloat32> flowIn) {
+  public static <T extends TType> TensorArraySplit create(Scope scope, Operand<?> handle, Operand<T> value, Operand<TInt64> lengths, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArraySplitV3", scope.makeOpName("TensorArraySplit"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(value.asOutput());
-    opBuilder.addInput(lengths.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
+    opBuilder.addInput(lengths.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorArraySplit(opBuilder.build());
   }
@@ -87,7 +87,7 @@ public Output<TFloat32> flowOut() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return flowOut;
   }
   
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 4097d9c5ed4..7609029568d 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -44,11 +44,11 @@ public final class TensorArrayUnpack extends RawOp implements Operand<TFloat32>
    * @return a new instance of TensorArrayUnpack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArrayUnpack create(Scope scope, Operand<TString> handle, Operand<T> value, Operand<TFloat32> flowIn) {
+  public static <T extends TType> TensorArrayUnpack create(Scope scope, Operand<TString> handle, Operand<T> value, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayUnpack", scope.makeOpName("TensorArrayUnpack"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(value.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorArrayUnpack(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<TFloat32> flowOut() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return flowOut;
   }
   
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 50c56c7acb9..c1657fa7766 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Push an element onto the tensor_array.
@@ -46,12 +46,12 @@ public final class TensorArrayWrite extends RawOp implements Operand<TFloat32> {
    * @return a new instance of TensorArrayWrite
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorArrayWrite create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<T> value, Operand<TFloat32> flowIn) {
+  public static <T extends TType> TensorArrayWrite create(Scope scope, Operand<?> handle, Operand<TInt32> index, Operand<T> value, Operand<TFloat32> flowIn) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorArrayWriteV3", scope.makeOpName("TensorArrayWrite"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(index.asOutput());
-    opBuilder.addInput(value.asOutput());
-    opBuilder.addInput(flowIn.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
+    opBuilder.addInput(flowIn.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorArrayWrite(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<TFloat32> flowOut() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return flowOut;
   }
   
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 ec0df709465..60ecc0a167f 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
@@ -42,8 +42,8 @@ public final class TensorForestCreateTreeVariable extends RawOp {
   @Endpoint(describeByClass = true)
   public static TensorForestCreateTreeVariable create(Scope scope, Operand<?> treeHandle, Operand<TString> treeConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorForestCreateTreeVariable", scope.makeOpName("TensorForestCreateTreeVariable"));
-    opBuilder.addInput(treeHandle.asOutput());
-    opBuilder.addInput(treeConfig.asOutput());
+    opBuilder.addInput(treeHandle.asOutput(scope));
+    opBuilder.addInput(treeConfig.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorForestCreateTreeVariable(opBuilder.build());
   }
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 a7585be7577..333c82856fc 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
@@ -42,8 +42,8 @@ public final class TensorForestTreeDeserialize extends RawOp {
   @Endpoint(describeByClass = true)
   public static TensorForestTreeDeserialize create(Scope scope, Operand<?> treeHandle, Operand<TString> treeConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorForestTreeDeserialize", scope.makeOpName("TensorForestTreeDeserialize"));
-    opBuilder.addInput(treeHandle.asOutput());
-    opBuilder.addInput(treeConfig.asOutput());
+    opBuilder.addInput(treeHandle.asOutput(scope));
+    opBuilder.addInput(treeConfig.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorForestTreeDeserialize(opBuilder.build());
   }
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 d0c39ab0de9..bb9198e81da 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
@@ -42,7 +42,7 @@ public final class TensorForestTreeIsInitializedOp extends RawOp implements Oper
   @Endpoint(describeByClass = true)
   public static TensorForestTreeIsInitializedOp create(Scope scope, Operand<?> treeHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorForestTreeIsInitializedOp", scope.makeOpName("TensorForestTreeIsInitializedOp"));
-    opBuilder.addInput(treeHandle.asOutput());
+    opBuilder.addInput(treeHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorForestTreeIsInitializedOp(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TBool> isInitialized() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return isInitialized;
   }
   
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 3b8dc79c2d9..9bf84d12204 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
@@ -44,8 +44,8 @@ public final class TensorForestTreePredict extends RawOp implements Operand<TFlo
   @Endpoint(describeByClass = true)
   public static TensorForestTreePredict create(Scope scope, Operand<?> treeHandle, Operand<TFloat32> denseFeatures, Long logitsDimension) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorForestTreePredict", scope.makeOpName("TensorForestTreePredict"));
-    opBuilder.addInput(treeHandle.asOutput());
-    opBuilder.addInput(denseFeatures.asOutput());
+    opBuilder.addInput(treeHandle.asOutput(scope));
+    opBuilder.addInput(denseFeatures.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("logits_dimension", logitsDimension);
     return new TensorForestTreePredict(opBuilder.build());
@@ -59,7 +59,7 @@ public Output<TFloat32> logits() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return logits;
   }
   
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 bc6656b08ce..933ff61790b 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a TensorForestTreeResource
  */
-public final class TensorForestTreeResourceHandleOp extends RawOp implements Operand<Tensor> {
+public final class TensorForestTreeResourceHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorForestTreeResourceHandleOp}
@@ -106,8 +106,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) resource;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) resource;
   }
   
   private Output<?> resource;
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 07838bb9028..e5fc809035b 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
@@ -42,7 +42,7 @@ public final class TensorForestTreeSerialize extends RawOp implements Operand<TS
   @Endpoint(describeByClass = true)
   public static TensorForestTreeSerialize create(Scope scope, Operand<?> treeHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorForestTreeSerialize", scope.makeOpName("TensorForestTreeSerialize"));
-    opBuilder.addInput(treeHandle.asOutput());
+    opBuilder.addInput(treeHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorForestTreeSerialize(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TString> treeConfig() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return treeConfig;
   }
   
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 03eddda317e..fad4fa80df1 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
@@ -42,7 +42,7 @@ public final class TensorForestTreeSize extends RawOp implements Operand<TInt32>
   @Endpoint(describeByClass = true)
   public static TensorForestTreeSize create(Scope scope, Operand<?> treeHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorForestTreeSize", scope.makeOpName("TensorForestTreeSize"));
-    opBuilder.addInput(treeHandle.asOutput());
+    opBuilder.addInput(treeHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorForestTreeSize(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TInt32> treeSize() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return treeSize;
   }
   
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 865466def45..c6656f14939 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Concats all tensors in the list along the 0th dimension.
@@ -49,7 +49,7 @@
  * @param <U> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListConcat<U extends Tensor> extends RawOp {
+public final class TensorListConcat<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorListConcat operation.
@@ -62,11 +62,11 @@ public final class TensorListConcat<U extends Tensor> extends RawOp {
    * @return a new instance of TensorListConcat
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> TensorListConcat<U> create(Scope scope, Operand<?> inputHandle, Operand<T> elementShape, Operand<TInt64> leadingDims, DataType<U> elementDtype) {
+  public static <U extends TType, T extends TNumber> TensorListConcat<U> create(Scope scope, Operand<?> inputHandle, Operand<T> elementShape, Operand<TInt64> leadingDims, DataType<U> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListConcatV2", scope.makeOpName("TensorListConcat"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
-    opBuilder.addInput(leadingDims.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
+    opBuilder.addInput(leadingDims.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     return new TensorListConcat<U>(opBuilder.build());
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 6df2a54a8dc..2f8982530dc 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,16 +22,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator
-public final class TensorListConcatLists extends RawOp implements Operand<Tensor> {
+public final class TensorListConcatLists extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListConcatLists operation.
@@ -43,10 +43,10 @@ public final class TensorListConcatLists extends RawOp implements Operand<Tensor
    * @return a new instance of TensorListConcatLists
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListConcatLists create(Scope scope, Operand<?> inputA, Operand<?> inputB, DataType<T> elementDtype) {
+  public static <T extends TType> TensorListConcatLists create(Scope scope, Operand<?> inputA, Operand<?> inputB, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListConcatLists", scope.makeOpName("TensorListConcatLists"));
-    opBuilder.addInput(inputA.asOutput());
-    opBuilder.addInput(inputB.asOutput());
+    opBuilder.addInput(inputA.asOutput(scope));
+    opBuilder.addInput(inputB.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     return new TensorListConcatLists(opBuilder.build());
@@ -60,8 +60,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 d11b994055b..f54f8f3bd3c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code elementShape()} output
  */
 @Operator
-public final class TensorListElementShape<T extends Tensor & TNumber> extends RawOp 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.
@@ -49,9 +48,9 @@ public final class TensorListElementShape<T extends Tensor & TNumber> extends Ra
    * @return a new instance of TensorListElementShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> TensorListElementShape<T> create(Scope scope, Operand<?> inputHandle, DataType<T> shapeType) {
+  public static <T extends TNumber> TensorListElementShape<T> create(Scope scope, Operand<?> inputHandle, DataType<T> shapeType) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListElementShape", scope.makeOpName("TensorListElementShape"));
-    opBuilder.addInput(inputHandle.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape_type", shapeType);
     return new TensorListElementShape<T>(opBuilder.build());
@@ -64,7 +63,7 @@ public Output<T> elementShape() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return elementShape;
   }
   
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 4c54936a199..4d5a77d3e36 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a TensorList which, when stacked, has the value of `tensor`.
@@ -37,7 +37,7 @@
  * output_handle: The list.
  */
 @Operator
-public final class TensorListFromTensor extends RawOp implements Operand<Tensor> {
+public final class TensorListFromTensor extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListFromTensor operation.
@@ -48,10 +48,10 @@ public final class TensorListFromTensor extends RawOp implements Operand<Tensor>
    * @return a new instance of TensorListFromTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> TensorListFromTensor create(Scope scope, Operand<T> tensor, Operand<U> elementShape) {
+  public static <T extends TType, U extends TNumber> TensorListFromTensor create(Scope scope, Operand<T> tensor, Operand<U> elementShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListFromTensor", scope.makeOpName("TensorListFromTensor"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListFromTensor(opBuilder.build());
   }
@@ -64,8 +64,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 0f041e6ee89..e1bd049ad99 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Tensor by indexing into the TensorList.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator
-public final class TensorListGather<T extends Tensor> extends RawOp 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.
@@ -55,11 +55,11 @@ public final class TensorListGather<T extends Tensor> extends RawOp implements O
    * @return a new instance of TensorListGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListGather<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> indices, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+  public static <T extends TType> TensorListGather<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> indices, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListGather", scope.makeOpName("TensorListGather"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     return new TensorListGather<T>(opBuilder.build());
@@ -72,7 +72,7 @@ public Output<T> values() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return values;
   }
   
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 c2c8e3a70fe..265e0838da4 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code item()} output
  */
 @Operator
-public final class TensorListGetItem<T extends Tensor> extends RawOp 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.
@@ -46,11 +46,11 @@ public final class TensorListGetItem<T extends Tensor> extends RawOp implements
    * @return a new instance of TensorListGetItem
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListGetItem<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+  public static <T extends TType> TensorListGetItem<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListGetItem", scope.makeOpName("TensorListGetItem"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(index.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     return new TensorListGetItem<T>(opBuilder.build());
@@ -63,7 +63,7 @@ public Output<T> item() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return item;
   }
   
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 c901d022f64..9d1ff503777 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
@@ -46,7 +46,7 @@ public final class TensorListLength extends RawOp implements Operand<TInt32> {
   @Endpoint(describeByClass = true)
   public static TensorListLength create(Scope scope, Operand<?> inputHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListLength", scope.makeOpName("TensorListLength"));
-    opBuilder.addInput(inputHandle.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListLength(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TInt32> length() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return length;
   }
   
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 a5e3393716b..c3844fb4560 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the last element of the input list as well as a list with all but that element.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListPopBack<T extends Tensor> extends RawOp {
+public final class TensorListPopBack<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new TensorListPopBack operation.
@@ -54,10 +54,10 @@ public final class TensorListPopBack<T extends Tensor> extends RawOp {
    * @return a new instance of TensorListPopBack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListPopBack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype) {
+  public static <T extends TType> TensorListPopBack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListPopBack", scope.makeOpName("TensorListPopBack"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     return new TensorListPopBack<T>(opBuilder.build());
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 cfe1f2ffb62..e0b2d2cbdd3 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
@@ -37,7 +37,7 @@
  * element_shape: a shape compatible with that of elements in the list.
  */
 @Operator
-public final class TensorListPushBack extends RawOp implements Operand<Tensor> {
+public final class TensorListPushBack extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListPushBack operation.
@@ -48,10 +48,10 @@ public final class TensorListPushBack extends RawOp implements Operand<Tensor> {
    * @return a new instance of TensorListPushBack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListPushBack create(Scope scope, Operand<?> inputHandle, Operand<T> tensor) {
+  public static <T extends TType> TensorListPushBack create(Scope scope, Operand<?> inputHandle, Operand<T> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListPushBack", scope.makeOpName("TensorListPushBack"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListPushBack(opBuilder.build());
   }
@@ -64,8 +64,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 ca102a1b817..4b401f22d64 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator
-public final class TensorListPushBackBatch extends RawOp implements Operand<Tensor> {
+public final class TensorListPushBackBatch extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListPushBackBatch operation.
@@ -41,10 +41,10 @@ public final class TensorListPushBackBatch extends RawOp implements Operand<Tens
    * @return a new instance of TensorListPushBackBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListPushBackBatch create(Scope scope, Operand<?> inputHandles, Operand<T> tensor) {
+  public static <T extends TType> TensorListPushBackBatch create(Scope scope, Operand<?> inputHandles, Operand<T> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListPushBackBatch", scope.makeOpName("TensorListPushBackBatch"));
-    opBuilder.addInput(inputHandles.asOutput());
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(inputHandles.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListPushBackBatch(opBuilder.build());
   }
@@ -57,8 +57,8 @@ public Output<?> outputHandles() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandles;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandles;
   }
   
   private Output<?> outputHandles;
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 39fa18038bb..1b16a2bd139 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * List of the given size with empty elements.
@@ -39,7 +39,7 @@
  * element_dtype: the desired type of elements in the list.
  */
 @Operator
-public final class TensorListReserve extends RawOp implements Operand<Tensor> {
+public final class TensorListReserve extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListReserve operation.
@@ -51,10 +51,10 @@ public final class TensorListReserve extends RawOp implements Operand<Tensor> {
    * @return a new instance of TensorListReserve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> TensorListReserve create(Scope scope, Operand<T> elementShape, Operand<TInt32> numElements, DataType<U> elementDtype) {
+  public static <T extends TNumber, U extends TType> TensorListReserve create(Scope scope, Operand<T> elementShape, Operand<TInt32> numElements, DataType<U> elementDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListReserve", scope.makeOpName("TensorListReserve"));
-    opBuilder.addInput(elementShape.asOutput());
-    opBuilder.addInput(numElements.asOutput());
+    opBuilder.addInput(elementShape.asOutput(scope));
+    opBuilder.addInput(numElements.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     return new TensorListReserve(opBuilder.build());
@@ -68,8 +68,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 2725a31c9a9..5722d10c881 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Resizes the list.
@@ -37,7 +37,7 @@
  * 
  */
 @Operator
-public final class TensorListResize extends RawOp implements Operand<Tensor> {
+public final class TensorListResize extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListResize operation.
@@ -50,8 +50,8 @@ public final class TensorListResize extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static TensorListResize create(Scope scope, Operand<?> inputHandle, Operand<TInt32> size) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListResize", scope.makeOpName("TensorListResize"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListResize(opBuilder.build());
   }
@@ -64,8 +64,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 8c0fe29e183..94a5ee7cbd1 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a TensorList by indexing into a Tensor.
@@ -45,7 +45,7 @@
  * output_handle: The TensorList.
  */
 @Operator
-public final class TensorListScatter extends RawOp implements Operand<Tensor> {
+public final class TensorListScatter extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListScatter operation.
@@ -58,12 +58,12 @@ public final class TensorListScatter extends RawOp implements Operand<Tensor> {
    * @return a new instance of TensorListScatter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> TensorListScatter create(Scope scope, Operand<T> tensor, Operand<TInt32> indices, Operand<U> elementShape, Operand<TInt32> numElements) {
+  public static <T extends TType, U extends TNumber> TensorListScatter create(Scope scope, Operand<T> tensor, Operand<TInt32> indices, Operand<U> elementShape, Operand<TInt32> numElements) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListScatterV2", scope.makeOpName("TensorListScatter"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
-    opBuilder.addInput(numElements.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
+    opBuilder.addInput(numElements.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListScatter(opBuilder.build());
   }
@@ -76,8 +76,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 a3fd37363ad..1ab6e03be7f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Scatters tensor at indices in an input list.
@@ -40,7 +40,7 @@
  * output_handle: The TensorList.
  */
 @Operator
-public final class TensorListScatterIntoExistingList extends RawOp implements Operand<Tensor> {
+public final class TensorListScatterIntoExistingList extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListScatterIntoExistingList operation.
@@ -52,11 +52,11 @@ public final class TensorListScatterIntoExistingList extends RawOp implements Op
    * @return a new instance of TensorListScatterIntoExistingList
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListScatterIntoExistingList create(Scope scope, Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
+  public static <T extends TType> TensorListScatterIntoExistingList create(Scope scope, Operand<?> inputHandle, Operand<T> tensor, Operand<TInt32> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListScatterIntoExistingList", scope.makeOpName("TensorListScatterIntoExistingList"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListScatterIntoExistingList(opBuilder.build());
   }
@@ -69,8 +69,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 cb58d32c56e..e1da3a7f29b 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator
-public final class TensorListSetItem extends RawOp implements Operand<Tensor> {
+public final class TensorListSetItem extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListSetItem operation.
@@ -43,11 +43,11 @@ public final class TensorListSetItem extends RawOp implements Operand<Tensor> {
    * @return a new instance of TensorListSetItem
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListSetItem create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<T> item) {
+  public static <T extends TType> TensorListSetItem create(Scope scope, Operand<?> inputHandle, Operand<TInt32> index, Operand<T> item) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListSetItem", scope.makeOpName("TensorListSetItem"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(index.asOutput());
-    opBuilder.addInput(item.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
+    opBuilder.addInput(item.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListSetItem(opBuilder.build());
   }
@@ -60,8 +60,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 a66063fecde..75ab46e90fd 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Splits a tensor into a list.
@@ -41,7 +41,7 @@
  * output_handle: The list.
  */
 @Operator
-public final class TensorListSplit extends RawOp implements Operand<Tensor> {
+public final class TensorListSplit extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorListSplit operation.
@@ -53,11 +53,11 @@ public final class TensorListSplit extends RawOp implements Operand<Tensor> {
    * @return a new instance of TensorListSplit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> TensorListSplit create(Scope scope, Operand<T> tensor, Operand<U> elementShape, Operand<TInt64> lengths) {
+  public static <T extends TType, U extends TNumber> TensorListSplit create(Scope scope, Operand<T> tensor, Operand<U> elementShape, Operand<TInt64> lengths) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListSplit", scope.makeOpName("TensorListSplit"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
-    opBuilder.addInput(lengths.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
+    opBuilder.addInput(lengths.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorListSplit(opBuilder.build());
   }
@@ -70,8 +70,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 c54d61f789d..3b48a056663 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Stacks all tensors in the list.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator
-public final class TensorListStack<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TensorListStack<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorListStack}
@@ -74,10 +74,10 @@ private Options() {
    * @return a new instance of TensorListStack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorListStack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype, Options... options) {
+  public static <T extends TType> TensorListStack<T> create(Scope scope, Operand<?> inputHandle, Operand<TInt32> elementShape, DataType<T> elementDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorListStack", scope.makeOpName("TensorListStack"));
-    opBuilder.addInput(inputHandle.asOutput());
-    opBuilder.addInput(elementShape.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
+    opBuilder.addInput(elementShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("element_dtype", elementDtype);
     if (options != null) {
@@ -104,7 +104,7 @@ public Output<T> tensor() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return tensor;
   }
   
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 c8904b41b82..3e79b0e5269 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds sparse `updates` to an existing tensor according to `indices`.
@@ -93,7 +93,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdAdd<T extends Tensor> extends RawOp 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.
@@ -105,11 +105,11 @@ public final class TensorScatterNdAdd<T extends Tensor> extends RawOp implements
    * @return a new instance of TensorScatterNdAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdAdd<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+  public static <T extends TType, U extends TNumber> TensorScatterNdAdd<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorScatterAdd", scope.makeOpName("TensorScatterNdAdd"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorScatterNdAdd<T>(opBuilder.build());
   }
@@ -122,7 +122,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 692cd043187..8d4d4398f6d 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Subtracts sparse `updates` from an existing tensor according to `indices`.
@@ -93,7 +93,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdSub<T extends Tensor> extends RawOp 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.
@@ -105,11 +105,11 @@ public final class TensorScatterNdSub<T extends Tensor> extends RawOp implements
    * @return a new instance of TensorScatterNdSub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdSub<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+  public static <T extends TType, U extends TNumber> TensorScatterNdSub<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorScatterSub", scope.makeOpName("TensorScatterNdSub"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorScatterNdSub<T>(opBuilder.build());
   }
@@ -122,7 +122,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 1966fe6d32b..33aa0d6a34f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Scatter `updates` into an existing tensor according to `indices`.
@@ -108,7 +108,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorScatterNdUpdate<T extends Tensor> extends RawOp 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.
@@ -120,11 +120,11 @@ public final class TensorScatterNdUpdate<T extends Tensor> extends RawOp impleme
    * @return a new instance of TensorScatterNdUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> TensorScatterNdUpdate<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
+  public static <T extends TType, U extends TNumber> TensorScatterNdUpdate<T> create(Scope scope, Operand<T> tensor, Operand<U> indices, Operand<T> updates) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorScatterUpdate", scope.makeOpName("TensorScatterNdUpdate"));
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorScatterNdUpdate<T>(opBuilder.build());
   }
@@ -138,7 +138,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 8eccd2bc1a0..d2bffce1369 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Assign `value` to the sliced l-value reference of `input`.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class TensorStridedSliceUpdate<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TensorStridedSliceUpdate<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.TensorStridedSliceUpdate}
@@ -111,13 +111,13 @@ private Options() {
    * @return a new instance of TensorStridedSliceUpdate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> TensorStridedSliceUpdate<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
+  public static <T extends TType, U extends TNumber> TensorStridedSliceUpdate<T> create(Scope scope, Operand<T> input, Operand<U> begin, Operand<U> end, Operand<U> strides, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorStridedSliceUpdate", scope.makeOpName("TensorStridedSliceUpdate"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(begin.asOutput());
-    opBuilder.addInput(end.asOutput());
-    opBuilder.addInput(strides.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(begin.asOutput(scope));
+    opBuilder.addInput(end.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -183,7 +183,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 f3321bd693e..8e0f93011fd 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Constructs a tensor by tiling a given tensor.
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Tile<T extends Tensor> extends RawOp 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.
@@ -72,10 +72,10 @@ public final class Tile<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Tile
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Tile<T> create(Scope scope, Operand<T> input, Operand<U> multiples) {
+  public static <T extends TType, U extends TNumber> Tile<T> create(Scope scope, Operand<T> input, Operand<U> multiples) {
     OperationBuilder opBuilder = scope.env().opBuilder("Tile", scope.makeOpName("Tile"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(multiples.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(multiples.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Tile<T>(opBuilder.build());
   }
@@ -87,7 +87,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ef460f466cd..197fe72b838 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
@@ -58,7 +58,7 @@ public Output<TFloat64> ts() {
   }
   
   @Override
-  public Output<TFloat64> asOutput() {
+  public Output<TFloat64> asOutput(Scope scope) {
     return ts;
   }
   
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 acb69b45d48..a3cf48ed4fa 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
@@ -141,9 +141,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static TryRpc create(Scope scope, Operand<TString> address, Operand<TString> method, Operand<TString> request, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TryRpc", scope.makeOpName("TryRpc"));
-    opBuilder.addInput(address.asOutput());
-    opBuilder.addInput(method.asOutput());
-    opBuilder.addInput(request.asOutput());
+    opBuilder.addInput(address.asOutput(scope));
+    opBuilder.addInput(method.asOutput(scope));
+    opBuilder.addInput(request.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 ae3b09713df..49c01d6c04a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reverses the operation of Batch for a single output Tensor.
@@ -53,7 +53,7 @@
  * @param <T> data type for {@code unbatchedTensor()} output
  */
 @Operator
-public final class Unbatch<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Unbatch<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unbatch}
@@ -95,11 +95,11 @@ private Options() {
    * @return a new instance of Unbatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Unbatch<T> create(Scope scope, Operand<T> batchedTensor, Operand<TInt64> batchIndex, Operand<TInt64> id, Long timeoutMicros, Options... options) {
+  public static <T extends TType> Unbatch<T> create(Scope scope, Operand<T> batchedTensor, Operand<TInt64> batchIndex, Operand<TInt64> id, Long timeoutMicros, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Unbatch", scope.makeOpName("Unbatch"));
-    opBuilder.addInput(batchedTensor.asOutput());
-    opBuilder.addInput(batchIndex.asOutput());
-    opBuilder.addInput(id.asOutput());
+    opBuilder.addInput(batchedTensor.asOutput(scope));
+    opBuilder.addInput(batchIndex.asOutput(scope));
+    opBuilder.addInput(id.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("timeout_micros", timeoutMicros);
     if (options != null) {
@@ -136,7 +136,7 @@ public Output<T> unbatchedTensor() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return unbatchedTensor;
   }
   
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 83fd34a1bb1..db1b637fb75 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gradient of Unbatch.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code batchedGrad()} output
  */
 @Operator
-public final class UnbatchGrad<T extends Tensor> extends RawOp implements Operand<T> {
+public final class UnbatchGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.UnbatchGrad}
@@ -91,12 +91,12 @@ private Options() {
    * @return a new instance of UnbatchGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> UnbatchGrad<T> create(Scope scope, Operand<T> originalInput, Operand<TInt64> batchIndex, Operand<T> grad, Operand<TInt64> id, Options... options) {
+  public static <T extends TType> UnbatchGrad<T> create(Scope scope, Operand<T> originalInput, Operand<TInt64> batchIndex, Operand<T> grad, Operand<TInt64> id, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnbatchGrad", scope.makeOpName("UnbatchGrad"));
-    opBuilder.addInput(originalInput.asOutput());
-    opBuilder.addInput(batchIndex.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(id.asOutput());
+    opBuilder.addInput(originalInput.asOutput(scope));
+    opBuilder.addInput(batchIndex.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(id.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -132,7 +132,7 @@ public Output<T> batchedGrad() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return batchedGrad;
   }
   
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 a1dac55fd27..6767929f009 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Finds unique elements along an axis of a tensor.
@@ -77,7 +77,7 @@
  * @param <V> data type for {@code idx()} output
  */
 @Operator
-public final class Unique<T extends Tensor, V extends Tensor & TNumber> extends RawOp {
+public final class Unique<T extends TType, V extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Unique operation.
@@ -90,10 +90,10 @@ public final class Unique<T extends Tensor, V extends Tensor & TNumber> extends
    * @return a new instance of Unique
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> Unique<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
+  public static <T extends TType, V extends TNumber, U extends TNumber> Unique<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
     OperationBuilder opBuilder = scope.env().opBuilder("UniqueV2", scope.makeOpName("Unique"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_idx", outIdx);
     return new Unique<T, V>(opBuilder.build());
@@ -109,7 +109,7 @@ public static <T extends Tensor, V extends Tensor & TNumber, U extends Tensor &
    * @return a new instance of Unique
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Unique<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
+  public static <T extends TType, U extends TNumber> Unique<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
     return create(scope, x, axis, TInt32.DTYPE);
   }
   
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 54efce5d00e..334f4755345 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Finds unique elements along an axis of a tensor.
@@ -81,7 +81,7 @@
  * @param <V> data type for {@code idx()} output
  */
 @Operator
-public final class UniqueWithCounts<T extends Tensor, V extends Tensor & TNumber> extends RawOp {
+public final class UniqueWithCounts<T extends TType, V extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new UniqueWithCounts operation.
@@ -94,10 +94,10 @@ public final class UniqueWithCounts<T extends Tensor, V extends Tensor & TNumber
    * @return a new instance of UniqueWithCounts
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, V extends Tensor & TNumber, U extends Tensor & TNumber> UniqueWithCounts<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
+  public static <T extends TType, V extends TNumber, U extends TNumber> UniqueWithCounts<T, V> create(Scope scope, Operand<T> x, Operand<U> axis, DataType<V> outIdx) {
     OperationBuilder opBuilder = scope.env().opBuilder("UniqueWithCountsV2", scope.makeOpName("UniqueWithCounts"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_idx", outIdx);
     return new UniqueWithCounts<T, V>(opBuilder.build());
@@ -113,7 +113,7 @@ public static <T extends Tensor, V extends Tensor & TNumber, U extends Tensor &
    * @return a new instance of UniqueWithCounts
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> UniqueWithCounts<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
+  public static <T extends TType, U extends TNumber> UniqueWithCounts<T, TInt32> create(Scope scope, Operand<T> x, Operand<U> axis) {
     return create(scope, x, axis, TInt32.DTYPE);
   }
   
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 a6efa567757..5b02cc366db 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -53,7 +52,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class UnravelIndex<T extends Tensor & TNumber> extends RawOp 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.
@@ -66,10 +65,10 @@ public final class UnravelIndex<T extends Tensor & TNumber> extends RawOp implem
    * @return a new instance of UnravelIndex
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> UnravelIndex<T> create(Scope scope, Operand<T> indices, Operand<T> dims) {
+  public static <T extends TNumber> UnravelIndex<T> create(Scope scope, Operand<T> indices, Operand<T> dims) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnravelIndex", scope.makeOpName("UnravelIndex"));
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(dims.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(dims.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new UnravelIndex<T>(opBuilder.build());
   }
@@ -83,7 +82,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 83d5f04b68c..b458f81540f 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,11 +24,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class Unstack<T extends Tensor> extends RawOp 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}
@@ -81,9 +81,9 @@ private Options() {
    * @return a new instance of Unstack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Unstack<T> create(Scope scope, Operand<T> value, Long num, Options... options) {
+  public static <T extends TType> Unstack<T> create(Scope scope, Operand<T> value, Long num, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Unpack", scope.makeOpName("Unstack"));
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num", num);
     if (options != null) {
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 b1f4560cd7e..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,11 +25,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Op is similar to a lightweight Dequeue.
@@ -38,7 +38,7 @@
  * capabilities and options.  This Op is optimized for performance.
  */
 @Operator
-public final class Unstage extends RawOp implements Iterable<Operand<Tensor>> {
+public final class Unstage extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Unstage}
@@ -158,7 +158,7 @@ public List<Output<?>> values() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) values.iterator();
   }
   
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 631b3b69a57..f6ba0f622f2 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies upper_bound(sorted_search_values, values) along each row.
@@ -53,7 +53,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class UpperBound<U extends Tensor & TNumber> extends RawOp 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.
@@ -66,10 +66,10 @@ public final class UpperBound<U extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of UpperBound
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> UpperBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
+  public static <U extends TNumber, T extends TType> UpperBound<U> create(Scope scope, Operand<T> sortedInputs, Operand<T> values, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("UpperBound", scope.makeOpName("UpperBound"));
-    opBuilder.addInput(sortedInputs.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(sortedInputs.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new UpperBound<U>(opBuilder.build());
@@ -85,7 +85,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> UpperBound<U> creat
    * @return a new instance of UpperBound
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> UpperBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
+  public static <T extends TType> UpperBound<TInt32> create(Scope scope, Operand<T> sortedInputs, Operand<T> values) {
     return create(scope, sortedInputs, values, TInt32.DTYPE);
   }
   
@@ -99,7 +99,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 d96c68cd4bc..91ec6da6944 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a Variable resource.
  */
 @Operator
-public final class VarHandleOp extends RawOp implements Operand<Tensor> {
+public final class VarHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.VarHandleOp}
@@ -74,7 +74,7 @@ private Options() {
    * @return a new instance of VarHandleOp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> VarHandleOp create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends TType> VarHandleOp create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("VarHandleOp", scope.makeOpName("VarHandleOp"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -114,8 +114,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) resource;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) resource;
   }
   
   private Output<?> resource;
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 0aaf43a2f1b..064206518e8 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
@@ -43,7 +43,7 @@ public final class VarIsInitializedOp extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static VarIsInitializedOp create(Scope scope, Operand<?> resource) {
     OperationBuilder opBuilder = scope.env().opBuilder("VarIsInitializedOp", scope.makeOpName("VarIsInitializedOp"));
-    opBuilder.addInput(resource.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new VarIsInitializedOp(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<TBool> isInitialized() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return isInitialized;
   }
   
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 c4d4fcadc85..474d3887f41 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Holds state in the form of a tensor that persists across steps.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code ref()} output
  */
 @Operator
-public final class Variable<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Variable<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.core.Variable}
@@ -81,7 +81,7 @@ private Options() {
    * @return a new instance of Variable
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Variable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
+  public static <T extends TType> Variable<T> create(Scope scope, Shape shape, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("VariableV2", scope.makeOpName("Variable"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
@@ -123,7 +123,7 @@ public Output<T> ref() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return ref;
   }
   
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 1535e676ff8..1e3b852bb68 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -45,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator
-public final class VariableShape<T extends Tensor & TNumber> extends RawOp 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.
@@ -56,9 +55,9 @@ public final class VariableShape<T extends Tensor & TNumber> extends RawOp imple
    * @return a new instance of VariableShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> VariableShape<T> create(Scope scope, Operand<?> input, DataType<T> outType) {
+  public static <T extends TNumber> VariableShape<T> create(Scope scope, Operand<?> input, DataType<T> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("VariableShape", scope.makeOpName("VariableShape"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new VariableShape<T>(opBuilder.build());
@@ -83,7 +82,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5c0f04ffea5..bcca08fb719 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns locations of nonzero / true values in a tensor.
@@ -102,9 +102,9 @@ public final class Where extends RawOp implements Operand<TInt64> {
    * @return a new instance of Where
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Where create(Scope scope, Operand<T> condition) {
+  public static <T extends TType> Where create(Scope scope, Operand<T> condition) {
     OperationBuilder opBuilder = scope.env().opBuilder("Where", scope.makeOpName("Where"));
-    opBuilder.addInput(condition.asOutput());
+    opBuilder.addInput(condition.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Where(opBuilder.build());
   }
@@ -116,7 +116,7 @@ public Output<TInt64> index() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return index;
   }
   
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 ca15edea6fa..ab9b74a1d30 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a tensor of zeros with the same shape and type as x.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator
-public final class ZerosLike<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class ZerosLike<T extends Tensor> extends RawOp implements Operand<
    * @return a new instance of ZerosLike
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ZerosLike<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> ZerosLike<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("ZerosLike", scope.makeOpName("ZerosLike"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ZerosLike<T>(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 fc6b7cdd1a8..12096ed388c 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * A transformation that asserts which transformations happen next.
@@ -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 RawOp implements Operand<Tensor> {
+public final class AssertNextDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new AssertNextDataset operation.
@@ -60,8 +60,8 @@ public final class AssertNextDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static AssertNextDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> transformations, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssertNextDataset", scope.makeOpName("AssertNextDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(transformations.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(transformations.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -84,8 +84,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 0eee666069d..99945419100 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that shards the input dataset.
@@ -42,7 +42,7 @@
  * This dataset will throw a NotFound error if we cannot shard the dataset
  * automatically.
  */
-public final class AutoShardDataset extends RawOp implements Operand<Tensor> {
+public final class AutoShardDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.AutoShardDataset}
@@ -78,9 +78,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static AutoShardDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numWorkers, Operand<TInt64> index, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AutoShardDataset", scope.makeOpName("AutoShardDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numWorkers.asOutput());
-    opBuilder.addInput(index.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numWorkers.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -117,8 +117,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d9f9ddcf257..4f626e386a6 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -31,12 +30,13 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches `batch_size` elements from `input_dataset`.
  */
 @Operator(group = "data")
-public final class BatchDataset extends RawOp implements Operand<Tensor> {
+public final class BatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.BatchDataset}
@@ -73,9 +73,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BatchDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> batchSize, Operand<TBool> dropRemainder, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchDatasetV2", scope.makeOpName("BatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(batchSize.asOutput());
-    opBuilder.addInput(dropRemainder.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(batchSize.asOutput(scope));
+    opBuilder.addInput(dropRemainder.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -112,8 +112,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 2814439f136..8acddcd2a98 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Records the bytes size of each element of `input_dataset` in a StatsAggregator.
  */
-public final class BytesProducedStatsDataset extends RawOp implements Operand<Tensor> {
+public final class BytesProducedStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BytesProducedStatsDataset operation.
@@ -49,8 +49,8 @@ public final class BytesProducedStatsDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static BytesProducedStatsDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> tag, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("BytesProducedStatsDataset", scope.makeOpName("BytesProducedStatsDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(tag.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 ab9df5fd412..8db1416bc72 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
@@ -22,7 +22,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -32,11 +31,12 @@
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "data")
-public final class CSVDataset extends RawOp implements Operand<Tensor> {
+public final class CSVDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CSVDataset operation.
@@ -57,15 +57,15 @@ public final class CSVDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static CSVDataset create(Scope scope, Operand<TString> filenames, Operand<TString> compressionType, Operand<TInt64> bufferSize, Operand<TBool> header, Operand<TString> fieldDelim, Operand<TBool> useQuoteDelim, Operand<TString> naValue, Operand<TInt64> selectCols, Iterable<Operand<?>> recordDefaults, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("CSVDataset", scope.makeOpName("CSVDataset"));
-    opBuilder.addInput(filenames.asOutput());
-    opBuilder.addInput(compressionType.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
-    opBuilder.addInput(header.asOutput());
-    opBuilder.addInput(fieldDelim.asOutput());
-    opBuilder.addInput(useQuoteDelim.asOutput());
-    opBuilder.addInput(naValue.asOutput());
-    opBuilder.addInput(selectCols.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(recordDefaults));
+    opBuilder.addInput(filenames.asOutput(scope));
+    opBuilder.addInput(compressionType.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
+    opBuilder.addInput(header.asOutput(scope));
+    opBuilder.addInput(fieldDelim.asOutput(scope));
+    opBuilder.addInput(useQuoteDelim.asOutput(scope));
+    opBuilder.addInput(naValue.asOutput(scope));
+    opBuilder.addInput(selectCols.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, recordDefaults));
     opBuilder = scope.applyControlDependencies(opBuilder);
     Shape[] outputShapesArray = new Shape[outputShapes.size()];
     for (int i = 0; i < outputShapesArray.length; ++i) {
@@ -83,8 +83,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 c5f86d5315b..c450343e4ee 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that caches elements from `input_dataset`.
@@ -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 RawOp implements Operand<Tensor> {
+public final class CacheDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CacheDataset operation.
@@ -55,8 +55,8 @@ public final class CacheDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static CacheDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> filename, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("CacheDataset", scope.makeOpName("CacheDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(filename.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(filename.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -79,8 +79,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 60ac1b2e25b..af4eec131a3 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class CacheDatasetV2 extends RawOp implements Operand<Tensor> {
+public final class CacheDatasetV2 extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CacheDatasetV2 operation.
@@ -49,9 +49,9 @@ public final class CacheDatasetV2 extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static CacheDatasetV2 create(Scope scope, Operand<?> inputDataset, Operand<TString> filename, Operand<?> cache, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("CacheDatasetV2", scope.makeOpName("CacheDatasetV2"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(filename.asOutput());
-    opBuilder.addInput(cache.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(filename.asOutput(scope));
+    opBuilder.addInput(cache.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -74,8 +74,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 6c99d42f352..22f063aad70 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
@@ -23,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class ChooseFastestDataset extends RawOp implements Operand<Tensor> {
+public final class ChooseFastestDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ChooseFastestDataset operation.
@@ -48,7 +48,7 @@ public final class ChooseFastestDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static ChooseFastestDataset create(Scope scope, Iterable<Operand<?>> inputDatasets, Long numExperiments, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ChooseFastestDataset", scope.makeOpName("ChooseFastestDataset"));
-    opBuilder.addInputList(Operands.asOutputs(inputDatasets));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputDatasets));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_experiments", numExperiments);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 6061f292ce2..e8b481c1a2c 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that concatenates `input_dataset` with `another_dataset`.
  */
 @Operator(group = "data")
-public final class ConcatenateDataset extends RawOp implements Operand<Tensor> {
+public final class ConcatenateDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ConcatenateDataset operation.
@@ -49,8 +49,8 @@ public final class ConcatenateDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static ConcatenateDataset create(Scope scope, Operand<?> inputDataset, Operand<?> anotherDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConcatenateDataset", scope.makeOpName("ConcatenateDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(anotherDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(anotherDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 44d118b6d32..e73ffba8596 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
@@ -44,7 +44,7 @@ public final class DatasetCardinality extends RawOp implements Operand<TInt64> {
   @Endpoint(describeByClass = true)
   public static DatasetCardinality create(Scope scope, Operand<?> inputDataset) {
     OperationBuilder opBuilder = scope.env().opBuilder("DatasetCardinality", scope.makeOpName("DatasetCardinality"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DatasetCardinality(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TInt64> cardinality() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return cardinality;
   }
   
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 6385afc04c6..f6480004fd4 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset from the given `graph_def`.
  * <p>
  * Creates a dataset from the provided `graph_def`.
  */
-public final class DatasetFromGraph extends RawOp implements Operand<Tensor> {
+public final class DatasetFromGraph extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DatasetFromGraph operation.
@@ -45,7 +45,7 @@ public final class DatasetFromGraph extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static DatasetFromGraph create(Scope scope, Operand<TString> graphDef) {
     OperationBuilder opBuilder = scope.env().opBuilder("DatasetFromGraph", scope.makeOpName("DatasetFromGraph"));
-    opBuilder.addInput(graphDef.asOutput());
+    opBuilder.addInput(graphDef.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DatasetFromGraph(opBuilder.build());
   }
@@ -59,8 +59,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 908aea9eb42..f280467d0ae 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
@@ -73,7 +73,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DatasetToGraph create(Scope scope, Operand<?> inputDataset, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DatasetToGraphV2", scope.makeOpName("DatasetToGraph"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -110,7 +110,7 @@ public Output<TString> graph() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return graph;
   }
   
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 e443a5be229..2d3cc56f0d6 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,17 +25,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs the single element from the given dataset.
  */
-public final class DatasetToSingleElement extends RawOp implements Iterable<Operand<Tensor>> {
+public final class DatasetToSingleElement extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new DatasetToSingleElement operation.
@@ -49,7 +49,7 @@ public final class DatasetToSingleElement extends RawOp implements Iterable<Oper
   @Endpoint(describeByClass = true)
   public static DatasetToSingleElement create(Scope scope, Operand<?> dataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("DatasetToSingleElement", scope.makeOpName("DatasetToSingleElement"));
-    opBuilder.addInput(dataset.asOutput());
+    opBuilder.addInput(dataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,7 +73,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 237f73b12a3..de989d4e59d 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
@@ -44,9 +44,9 @@ public final class DatasetToTfRecord extends RawOp {
   @Endpoint(describeByClass = true)
   public static DatasetToTfRecord create(Scope scope, Operand<?> inputDataset, Operand<TString> filename, Operand<TString> compressionType) {
     OperationBuilder opBuilder = scope.env().opBuilder("DatasetToTFRecord", scope.makeOpName("DatasetToTfRecord"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(filename.asOutput());
-    opBuilder.addInput(compressionType.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(filename.asOutput(scope));
+    opBuilder.addInput(compressionType.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DatasetToTfRecord(opBuilder.build());
   }
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 5a92fcb5f82..81a53aaff6c 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
@@ -42,8 +42,8 @@ public final class DeleteIterator extends RawOp {
   @Endpoint(describeByClass = true)
   public static DeleteIterator create(Scope scope, Operand<?> handle, Operand<?> deleter) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeleteIterator", scope.makeOpName("DeleteIterator"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(deleter.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(deleter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DeleteIterator(opBuilder.build());
   }
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 06077aae830..5d499301e4a 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
@@ -40,8 +40,8 @@ public final class DeleteMemoryCache extends RawOp {
   @Endpoint(describeByClass = true)
   public static DeleteMemoryCache create(Scope scope, Operand<?> handle, Operand<?> deleter) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeleteMemoryCache", scope.makeOpName("DeleteMemoryCache"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(deleter.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(deleter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DeleteMemoryCache(opBuilder.build());
   }
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 5786255bfa5..1edde97b078 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
@@ -43,9 +43,9 @@ public final class DeleteMultiDeviceIterator extends RawOp {
   @Endpoint(describeByClass = true)
   public static DeleteMultiDeviceIterator create(Scope scope, Operand<?> multiDeviceIterator, Iterable<Operand<?>> iterators, Operand<?> deleter) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeleteMultiDeviceIterator", scope.makeOpName("DeleteMultiDeviceIterator"));
-    opBuilder.addInput(multiDeviceIterator.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(iterators));
-    opBuilder.addInput(deleter.asOutput());
+    opBuilder.addInput(multiDeviceIterator.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, iterators));
+    opBuilder.addInput(deleter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DeleteMultiDeviceIterator(opBuilder.build());
   }
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 dfa1b4e3c30..3dfb1268882 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches input elements into a SparseTensor.
  */
-public final class DenseToSparseBatchDataset extends RawOp implements Operand<Tensor> {
+public final class DenseToSparseBatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DenseToSparseBatchDataset operation.
@@ -53,9 +53,9 @@ public final class DenseToSparseBatchDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static DenseToSparseBatchDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> batchSize, Operand<TInt64> rowShape, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("DenseToSparseBatchDataset", scope.makeOpName("DenseToSparseBatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(batchSize.asOutput());
-    opBuilder.addInput(rowShape.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(batchSize.asOutput(scope));
+    opBuilder.addInput(rowShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -78,8 +78,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 a8c05b2d5ad..f7834b6d1c0 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
@@ -43,8 +43,8 @@ public final class DeserializeIterator extends RawOp {
   @Endpoint(describeByClass = true)
   public static DeserializeIterator create(Scope scope, Operand<?> resourceHandle, Operand<?> serialized) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeserializeIterator", scope.makeOpName("DeserializeIterator"));
-    opBuilder.addInput(resourceHandle.asOutput());
-    opBuilder.addInput(serialized.asOutput());
+    opBuilder.addInput(resourceHandle.asOutput(scope));
+    opBuilder.addInput(serialized.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DeserializeIterator(opBuilder.build());
   }
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 d1457a5cd15..88064eafa0e 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
@@ -23,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
  */
-public final class DirectedInterleaveDataset extends RawOp implements Operand<Tensor> {
+public final class DirectedInterleaveDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DirectedInterleaveDataset operation.
@@ -51,8 +51,8 @@ public final class DirectedInterleaveDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static DirectedInterleaveDataset create(Scope scope, Operand<?> selectorInputDataset, Iterable<Operand<?>> dataInputDatasets, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("DirectedInterleaveDataset", scope.makeOpName("DirectedInterleaveDataset"));
-    opBuilder.addInput(selectorInputDataset.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(dataInputDatasets));
+    opBuilder.addInput(selectorInputDataset.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, dataInputDatasets));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 837e10a5075..8116c65ccf0 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset containing elements of first component of `input_dataset` having true in the last component.
  */
-public final class FilterByLastComponentDataset extends RawOp implements Operand<Tensor> {
+public final class FilterByLastComponentDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new FilterByLastComponentDataset operation.
@@ -47,7 +47,7 @@ public final class FilterByLastComponentDataset extends RawOp implements Operand
   @Endpoint(describeByClass = true)
   public static FilterByLastComponentDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("FilterByLastComponentDataset", scope.makeOpName("FilterByLastComponentDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 c22422668d7..962ad96daad 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class FixedLengthRecordDataset extends RawOp implements Operand<Tensor> {
+public final class FixedLengthRecordDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new FixedLengthRecordDataset operation.
@@ -48,12 +48,12 @@ public final class FixedLengthRecordDataset extends RawOp implements Operand<Ten
   @Endpoint(describeByClass = true)
   public static FixedLengthRecordDataset create(Scope scope, Operand<TString> filenames, Operand<TInt64> headerBytes, Operand<TInt64> recordBytes, Operand<TInt64> footerBytes, Operand<TInt64> bufferSize, Operand<TString> compressionType) {
     OperationBuilder opBuilder = scope.env().opBuilder("FixedLengthRecordDatasetV2", scope.makeOpName("FixedLengthRecordDataset"));
-    opBuilder.addInput(filenames.asOutput());
-    opBuilder.addInput(headerBytes.asOutput());
-    opBuilder.addInput(recordBytes.asOutput());
-    opBuilder.addInput(footerBytes.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
-    opBuilder.addInput(compressionType.asOutput());
+    opBuilder.addInput(filenames.asOutput(scope));
+    opBuilder.addInput(headerBytes.asOutput(scope));
+    opBuilder.addInput(recordBytes.asOutput(scope));
+    opBuilder.addInput(footerBytes.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
+    opBuilder.addInput(compressionType.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new FixedLengthRecordDataset(opBuilder.build());
   }
@@ -66,8 +66,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 89f888b2ee0..ebba0ba4367 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the elements of `input_dataset` ignoring errors.
  */
-public final class IgnoreErrorsDataset extends RawOp implements Operand<Tensor> {
+public final class IgnoreErrorsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new IgnoreErrorsDataset operation.
@@ -47,7 +47,7 @@ public final class IgnoreErrorsDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static IgnoreErrorsDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("IgnoreErrorsDataset", scope.makeOpName("IgnoreErrorsDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 6d19c38ebbc..24ceb94472f 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "data")
-public final class Iterator extends RawOp implements Operand<Tensor> {
+public final class Iterator extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new Iterator operation.
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 e11f138010a..8950b22db06 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class IteratorFromStringHandle extends RawOp implements Operand<Tensor> {
+public final class IteratorFromStringHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.IteratorFromStringHandle}
@@ -66,7 +66,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static IteratorFromStringHandle create(Scope scope, Operand<TString> stringHandle, List<DataType<?>> outputTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("IteratorFromStringHandleV2", scope.makeOpName("IteratorFromStringHandle"));
-    opBuilder.addInput(stringHandle.asOutput());
+    opBuilder.addInput(stringHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -102,8 +102,8 @@ public Output<?> resourceHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) resourceHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) resourceHandle;
   }
   
   private Output<?> resourceHandle;
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 d1ac024b6b2..e2b4895501d 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
@@ -42,7 +42,7 @@ public final class IteratorGetDevice extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static IteratorGetDevice create(Scope scope, Operand<?> resource) {
     OperationBuilder opBuilder = scope.env().opBuilder("IteratorGetDevice", scope.makeOpName("IteratorGetDevice"));
-    opBuilder.addInput(resource.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IteratorGetDevice(opBuilder.build());
   }
@@ -54,7 +54,7 @@ public Output<TString> device() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return device;
   }
   
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 fff3f61fef0..ecba5e71b91 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,18 +25,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gets the next output from the given iterator .
  */
 @Operator(group = "data")
-public final class IteratorGetNext extends RawOp implements Iterable<Operand<Tensor>> {
+public final class IteratorGetNext extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNext operation.
@@ -50,7 +50,7 @@ public final class IteratorGetNext extends RawOp implements Iterable<Operand<Ten
   @Endpoint(describeByClass = true)
   public static IteratorGetNext create(Scope scope, Operand<?> iterator, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("IteratorGetNext", scope.makeOpName("IteratorGetNext"));
-    opBuilder.addInput(iterator.asOutput());
+    opBuilder.addInput(iterator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,7 +73,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 66848107ede..b0eef7da752 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gets the next output from the given iterator as an Optional variant.
  */
 @Operator(group = "data")
-public final class IteratorGetNextAsOptional extends RawOp implements Operand<Tensor> {
+public final class IteratorGetNextAsOptional extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNextAsOptional operation.
@@ -48,7 +48,7 @@ public final class IteratorGetNextAsOptional extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static IteratorGetNextAsOptional create(Scope scope, Operand<?> iterator, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("IteratorGetNextAsOptional", scope.makeOpName("IteratorGetNextAsOptional"));
-    opBuilder.addInput(iterator.asOutput());
+    opBuilder.addInput(iterator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -71,8 +71,8 @@ public Output<?> optional() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) optional;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) optional;
   }
   
   private Output<?> optional;
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 0054accfaa4..13e3fd73513 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gets the next output from the given iterator.
@@ -41,7 +41,7 @@
  * operations (e.g. in eager mode).
  */
 @Operator(group = "data")
-public final class IteratorGetNextSync extends RawOp implements Iterable<Operand<Tensor>> {
+public final class IteratorGetNextSync extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new IteratorGetNextSync operation.
@@ -55,7 +55,7 @@ public final class IteratorGetNextSync extends RawOp implements Iterable<Operand
   @Endpoint(describeByClass = true)
   public static IteratorGetNextSync create(Scope scope, Operand<?> iterator, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("IteratorGetNextSync", scope.makeOpName("IteratorGetNextSync"));
-    opBuilder.addInput(iterator.asOutput());
+    opBuilder.addInput(iterator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -78,7 +78,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 19e8fcf2ed4..c49ebfa2ebf 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
@@ -43,7 +43,7 @@ public final class IteratorToStringHandle extends RawOp implements Operand<TStri
   @Endpoint(describeByClass = true)
   public static IteratorToStringHandle create(Scope scope, Operand<?> resourceHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("IteratorToStringHandle", scope.makeOpName("IteratorToStringHandle"));
-    opBuilder.addInput(resourceHandle.asOutput());
+    opBuilder.addInput(resourceHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IteratorToStringHandle(opBuilder.build());
   }
@@ -56,7 +56,7 @@ public Output<TString> stringHandle() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return stringHandle;
   }
   
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 100b7a20375..99becc6a664 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the key-value pairs in one or more LMDB files.
@@ -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 RawOp implements Operand<Tensor> {
+public final class LMDBDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LMDBDataset operation.
@@ -60,7 +60,7 @@ public final class LMDBDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static LMDBDataset create(Scope scope, Operand<TString> filenames, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("LMDBDataset", scope.makeOpName("LMDBDataset"));
-    opBuilder.addInput(filenames.asOutput());
+    opBuilder.addInput(filenames.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -83,8 +83,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d2f4856c37c..0036ce2834a 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Records the latency of producing `input_dataset` elements in a StatsAggregator.
  */
-public final class LatencyStatsDataset extends RawOp implements Operand<Tensor> {
+public final class LatencyStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LatencyStatsDataset operation.
@@ -49,8 +49,8 @@ public final class LatencyStatsDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static LatencyStatsDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> tag, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("LatencyStatsDataset", scope.makeOpName("LatencyStatsDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(tag.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 433d7c8694a..45f9585b648 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class LeakyReluGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class LeakyReluGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.LeakyReluGrad}
@@ -65,10 +64,10 @@ private Options() {
    * @return a new instance of LeakyReluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LeakyReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features, Options... options) {
+  public static <T extends TNumber> LeakyReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LeakyReluGrad", scope.makeOpName("LeakyReluGrad"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -95,7 +94,7 @@ public Output<T> backprops() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return backprops;
   }
   
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 a2f380b0a49..4a2f76ef049 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
@@ -45,8 +45,8 @@ public final class MakeIterator extends RawOp {
   @Endpoint(describeByClass = true)
   public static MakeIterator create(Scope scope, Operand<?> dataset, Operand<?> iterator) {
     OperationBuilder opBuilder = scope.env().opBuilder("MakeIterator", scope.makeOpName("MakeIterator"));
-    opBuilder.addInput(dataset.asOutput());
-    opBuilder.addInput(iterator.asOutput());
+    opBuilder.addInput(dataset.asOutput(scope));
+    opBuilder.addInput(iterator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MakeIterator(opBuilder.build());
   }
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 dd16a48fdd0..923e89bc7d3 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class MatchingFilesDataset extends RawOp implements Operand<Tensor> {
+public final class MatchingFilesDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MatchingFilesDataset operation.
@@ -42,7 +42,7 @@ public final class MatchingFilesDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static MatchingFilesDataset create(Scope scope, Operand<TString> patterns) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatchingFilesDataset", scope.makeOpName("MatchingFilesDataset"));
-    opBuilder.addInput(patterns.asOutput());
+    opBuilder.addInput(patterns.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MatchingFilesDataset(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 ebb959b1aee..70f106190e4 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that overrides the maximum intra-op parallelism.
  */
-public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<Tensor> {
+public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MaxIntraOpParallelismDataset operation.
@@ -49,8 +49,8 @@ public final class MaxIntraOpParallelismDataset extends RawOp implements Operand
   @Endpoint(describeByClass = true)
   public static MaxIntraOpParallelismDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> maxIntraOpParallelism, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxIntraOpParallelismDataset", scope.makeOpName("MaxIntraOpParallelismDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(maxIntraOpParallelism.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(maxIntraOpParallelism.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 9e7df64f13a..302c21d0283 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Identity transformation that models performance.
  * <p>
  * Identity transformation that models performance.
  */
-public final class ModelDataset extends RawOp implements Operand<Tensor> {
+public final class ModelDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ModelDataset}
@@ -78,7 +78,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ModelDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ModelDataset", scope.makeOpName("ModelDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -125,8 +125,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 492742707d7..11381cb40e7 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a MultiDeviceIterator resource.
  */
-public final class MultiDeviceIterator extends RawOp implements Operand<Tensor> {
+public final class MultiDeviceIterator extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIterator operation.
@@ -81,8 +81,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d83ecb8d9fa..a1db07d4fdc 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Generates a MultiDeviceIterator resource from its provided string handle.
  */
-public final class MultiDeviceIteratorFromStringHandle extends RawOp implements Operand<Tensor> {
+public final class MultiDeviceIteratorFromStringHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.MultiDeviceIteratorFromStringHandle}
@@ -67,7 +67,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static MultiDeviceIteratorFromStringHandle create(Scope scope, Operand<TString> stringHandle, List<DataType<?>> outputTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MultiDeviceIteratorFromStringHandle", scope.makeOpName("MultiDeviceIteratorFromStringHandle"));
-    opBuilder.addInput(stringHandle.asOutput());
+    opBuilder.addInput(stringHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -104,8 +104,8 @@ public Output<?> multiDeviceIterator() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) multiDeviceIterator;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) multiDeviceIterator;
   }
   
   private Output<?> multiDeviceIterator;
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 993b824c384..53f57853e82 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -33,11 +32,12 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gets next element for the provided shard number.
  */
-public final class MultiDeviceIteratorGetNextFromShard extends RawOp implements Iterable<Operand<Tensor>> {
+public final class MultiDeviceIteratorGetNextFromShard extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new MultiDeviceIteratorGetNextFromShard operation.
@@ -53,9 +53,9 @@ public final class MultiDeviceIteratorGetNextFromShard extends RawOp implements
   @Endpoint(describeByClass = true)
   public static MultiDeviceIteratorGetNextFromShard create(Scope scope, Operand<?> multiDeviceIterator, Operand<TInt32> shardNum, Operand<TInt64> incarnationId, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("MultiDeviceIteratorGetNextFromShard", scope.makeOpName("MultiDeviceIteratorGetNextFromShard"));
-    opBuilder.addInput(multiDeviceIterator.asOutput());
-    opBuilder.addInput(shardNum.asOutput());
-    opBuilder.addInput(incarnationId.asOutput());
+    opBuilder.addInput(multiDeviceIterator.asOutput(scope));
+    opBuilder.addInput(shardNum.asOutput(scope));
+    opBuilder.addInput(incarnationId.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -79,7 +79,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 fec8ee78e0b..764ae8b6464 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
@@ -44,9 +44,9 @@ public final class MultiDeviceIteratorInit extends RawOp implements Operand<TInt
   @Endpoint(describeByClass = true)
   public static MultiDeviceIteratorInit create(Scope scope, Operand<?> dataset, Operand<?> multiDeviceIterator, Operand<TInt64> maxBufferSize) {
     OperationBuilder opBuilder = scope.env().opBuilder("MultiDeviceIteratorInit", scope.makeOpName("MultiDeviceIteratorInit"));
-    opBuilder.addInput(dataset.asOutput());
-    opBuilder.addInput(multiDeviceIterator.asOutput());
-    opBuilder.addInput(maxBufferSize.asOutput());
+    opBuilder.addInput(dataset.asOutput(scope));
+    opBuilder.addInput(multiDeviceIterator.asOutput(scope));
+    opBuilder.addInput(maxBufferSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MultiDeviceIteratorInit(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<TInt64> incarnationId() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return incarnationId;
   }
   
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 6f6045a848c..06487f74111 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
@@ -42,7 +42,7 @@ public final class MultiDeviceIteratorToStringHandle extends RawOp implements Op
   @Endpoint(describeByClass = true)
   public static MultiDeviceIteratorToStringHandle create(Scope scope, Operand<?> multiDeviceIterator) {
     OperationBuilder opBuilder = scope.env().opBuilder("MultiDeviceIteratorToStringHandle", scope.makeOpName("MultiDeviceIteratorToStringHandle"));
-    opBuilder.addInput(multiDeviceIterator.asOutput());
+    opBuilder.addInput(multiDeviceIterator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MultiDeviceIteratorToStringHandle(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TString> stringHandle() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return stringHandle;
   }
   
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 3f3f8645349..3e9694fab5e 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,16 +23,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class NonSerializableDataset extends RawOp implements Operand<Tensor> {
+public final class NonSerializableDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new NonSerializableDataset operation.
@@ -46,7 +46,7 @@ public final class NonSerializableDataset extends RawOp implements Operand<Tenso
   @Endpoint(describeByClass = true)
   public static NonSerializableDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("NonSerializableDataset", scope.makeOpName("NonSerializableDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -69,8 +69,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d2cbd47fbf5..f2e311409ed 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,20 +23,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset by applying optimizations to `input_dataset`.
  * <p>
  * Creates a dataset by applying optimizations to `input_dataset`.
  */
-public final class OptimizeDataset extends RawOp implements Operand<Tensor> {
+public final class OptimizeDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.OptimizeDataset}
@@ -71,8 +71,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static OptimizeDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> optimizations, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OptimizeDataset", scope.makeOpName("OptimizeDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(optimizations.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(optimizations.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -113,8 +113,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 2b0a40acd23..be8865ecbf7 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
@@ -21,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Constructs an Optional variant from a tuple of tensors.
  */
 @Operator(group = "data")
-public final class OptionalFromValue extends RawOp implements Operand<Tensor> {
+public final class OptionalFromValue extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new OptionalFromValue operation.
@@ -44,7 +44,7 @@ public final class OptionalFromValue extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static OptionalFromValue create(Scope scope, Iterable<Operand<?>> components) {
     OperationBuilder opBuilder = scope.env().opBuilder("OptionalFromValue", scope.makeOpName("OptionalFromValue"));
-    opBuilder.addInputList(Operands.asOutputs(components));
+    opBuilder.addInputList(Operands.asOutputs(scope, components));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new OptionalFromValue(opBuilder.build());
   }
@@ -57,8 +57,8 @@ public Output<?> optional() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) optional;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) optional;
   }
   
   private Output<?> optional;
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 b7a04b5c862..396ad376b03 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,18 +25,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the value stored in an Optional variant or raises an error if none exists.
  */
 @Operator(group = "data")
-public final class OptionalGetValue extends RawOp implements Iterable<Operand<Tensor>> {
+public final class OptionalGetValue extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new OptionalGetValue operation.
@@ -50,7 +50,7 @@ public final class OptionalGetValue extends RawOp implements Iterable<Operand<Te
   @Endpoint(describeByClass = true)
   public static OptionalGetValue create(Scope scope, Operand<?> optional, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("OptionalGetValue", scope.makeOpName("OptionalGetValue"));
-    opBuilder.addInput(optional.asOutput());
+    opBuilder.addInput(optional.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,7 +73,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 d77f53ff5ca..82c206e1755 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
@@ -43,7 +43,7 @@ public final class OptionalHasValue extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static OptionalHasValue create(Scope scope, Operand<?> optional) {
     OperationBuilder opBuilder = scope.env().opBuilder("OptionalHasValue", scope.makeOpName("OptionalHasValue"));
-    opBuilder.addInput(optional.asOutput());
+    opBuilder.addInput(optional.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new OptionalHasValue(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TBool> hasValue() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return hasValue;
   }
   
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 ddeb8360e5d..dae4fbf3b0e 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates an Optional variant with no value.
  */
 @Operator(group = "data")
-public final class OptionalNone extends RawOp implements Operand<Tensor> {
+public final class OptionalNone extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new OptionalNone operation.
@@ -54,8 +54,8 @@ public Output<?> optional() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) optional;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) optional;
   }
   
   private Output<?> optional;
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 d4cb445eae1..b96c9519426 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
@@ -22,7 +22,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -31,11 +30,12 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches and pads `batch_size` elements from the input.
  */
-public final class PaddedBatchDataset extends RawOp implements Operand<Tensor> {
+public final class PaddedBatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.PaddedBatchDataset}
@@ -78,11 +78,11 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static PaddedBatchDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> batchSize, Iterable<Operand<TInt64>> paddedShapes, Iterable<Operand<?>> paddingValues, Operand<TBool> dropRemainder, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("PaddedBatchDatasetV2", scope.makeOpName("PaddedBatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(batchSize.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(paddedShapes));
-    opBuilder.addInputList(Operands.asOutputs(paddingValues));
-    opBuilder.addInput(dropRemainder.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(batchSize.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, paddedShapes));
+    opBuilder.addInputList(Operands.asOutputs(scope, paddingValues));
+    opBuilder.addInput(dropRemainder.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     Shape[] outputShapesArray = new Shape[outputShapes.size()];
     for (int i = 0; i < outputShapesArray.length; ++i) {
@@ -114,8 +114,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d7b0daf9b65..720a06118a4 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that asynchronously prefetches elements from `input_dataset`.
  */
-public final class PrefetchDataset extends RawOp implements Operand<Tensor> {
+public final class PrefetchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.PrefetchDataset}
@@ -79,8 +79,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static PrefetchDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> bufferSize, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("PrefetchDataset", scope.makeOpName("PrefetchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -127,8 +127,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 4ea02d5341b..c50a380c847 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class PrivateThreadPoolDataset extends RawOp implements Operand<Tensor> {
+public final class PrivateThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new PrivateThreadPoolDataset operation.
@@ -49,8 +49,8 @@ public final class PrivateThreadPoolDataset extends RawOp implements Operand<Ten
   @Endpoint(describeByClass = true)
   public static PrivateThreadPoolDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numThreads, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("PrivateThreadPoolDataset", scope.makeOpName("PrivateThreadPoolDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numThreads.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numThreads.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 12e055eaf3c..b87f138310e 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Dataset that returns pseudorandom numbers.
@@ -45,7 +45,7 @@
  * performed is determined by the `experimental_optimization.hoist_random_uniform`
  * option of `tf.data.Options`.
  */
-public final class RandomDataset extends RawOp implements Operand<Tensor> {
+public final class RandomDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RandomDataset operation.
@@ -62,8 +62,8 @@ public final class RandomDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static RandomDataset create(Scope scope, Operand<TInt64> seed, Operand<TInt64> seed2, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomDataset", scope.makeOpName("RandomDataset"));
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(seed2.asOutput());
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(seed2.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -86,8 +86,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 0c24aa899ea..125ff8b8f81 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset with a range of values. Corresponds to python's xrange.
  */
 @Operator(group = "data")
-public final class RangeDataset extends RawOp implements Operand<Tensor> {
+public final class RangeDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RangeDataset operation.
@@ -51,9 +51,9 @@ public final class RangeDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static RangeDataset create(Scope scope, Operand<TInt64> start, Operand<TInt64> stop, Operand<TInt64> step, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("RangeDataset", scope.makeOpName("RangeDataset"));
-    opBuilder.addInput(start.asOutput());
-    opBuilder.addInput(stop.asOutput());
-    opBuilder.addInput(step.asOutput());
+    opBuilder.addInput(start.asOutput(scope));
+    opBuilder.addInput(stop.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 3d54c01ab3c..a688e0de880 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that changes the batch size.
@@ -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 RawOp implements Operand<Tensor> {
+public final class RebatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.RebatchDataset}
@@ -74,8 +74,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static RebatchDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numReplicas, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RebatchDataset", scope.makeOpName("RebatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numReplicas.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numReplicas.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -112,8 +112,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 58b629facd1..b04cbf38227 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the outputs of `input_dataset` `count` times.
  */
 @Operator(group = "data")
-public final class RepeatDataset extends RawOp implements Operand<Tensor> {
+public final class RepeatDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RepeatDataset operation.
@@ -51,8 +51,8 @@ public final class RepeatDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static RepeatDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> count, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("RepeatDataset", scope.makeOpName("RepeatDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(count.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(count.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 e8e100c9cc8..d694f4136d0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -31,6 +30,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that takes a Bernoulli sample of the contents of another dataset.
@@ -41,7 +41,7 @@
  * `experimental_optimization.filter_with_random_uniform_fusion` option of
  * `tf.data.Options`.
  */
-public final class SamplingDataset extends RawOp implements Operand<Tensor> {
+public final class SamplingDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SamplingDataset operation.
@@ -59,10 +59,10 @@ public final class SamplingDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static SamplingDataset create(Scope scope, Operand<?> inputDataset, Operand<TFloat32> rate, Operand<TInt64> seed, Operand<TInt64> seed2, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("SamplingDataset", scope.makeOpName("SamplingDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(rate.asOutput());
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(seed2.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(rate.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(seed2.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -85,8 +85,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 6393b34d8f5..e5dbb52d68d 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts the given `resource_handle` representing an iterator to a variant tensor.
  */
 @Operator(group = "data")
-public final class SerializeIterator extends RawOp implements Operand<Tensor> {
+public final class SerializeIterator extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.SerializeIterator}
@@ -63,7 +63,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static SerializeIterator create(Scope scope, Operand<?> resourceHandle, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SerializeIterator", scope.makeOpName("SerializeIterator"));
-    opBuilder.addInput(resourceHandle.asOutput());
+    opBuilder.addInput(resourceHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -92,8 +92,8 @@ public Output<?> serialized() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) serialized;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) serialized;
   }
   
   private Output<?> serialized;
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 1824909ba01..6050f9e3615 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SetStatsAggregatorDataset extends RawOp implements Operand<Tensor> {
+public final class SetStatsAggregatorDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SetStatsAggregatorDataset operation.
@@ -50,10 +50,10 @@ public final class SetStatsAggregatorDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static SetStatsAggregatorDataset create(Scope scope, Operand<?> inputDataset, Operand<?> statsAggregator, Operand<TString> tag, Operand<TString> counterPrefix, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("SetStatsAggregatorDataset", scope.makeOpName("SetStatsAggregatorDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(statsAggregator.asOutput());
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(counterPrefix.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(statsAggregator.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(counterPrefix.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 7703b7395ea..2180603b076 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a `Dataset` that includes only 1/`num_shards` of this dataset.
  */
-public final class ShardDataset extends RawOp implements Operand<Tensor> {
+public final class ShardDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ShardDataset}
@@ -70,9 +70,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ShardDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numShards, Operand<TInt64> index, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ShardDataset", scope.makeOpName("ShardDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numShards.asOutput());
-    opBuilder.addInput(index.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numShards.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -109,8 +109,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 0c50b8fcb1f..13a629bb3c8 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,20 +23,20 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that shuffles and repeats elements from `input_dataset`
  * <p>
  * pseudorandomly.
  */
-public final class ShuffleAndRepeatDataset extends RawOp implements Operand<Tensor> {
+public final class ShuffleAndRepeatDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ShuffleAndRepeatDataset operation.
@@ -59,11 +59,11 @@ public final class ShuffleAndRepeatDataset extends RawOp implements Operand<Tens
   @Endpoint(describeByClass = true)
   public static ShuffleAndRepeatDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> bufferSize, Operand<TInt64> seed, Operand<TInt64> seed2, Operand<TInt64> count, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ShuffleAndRepeatDataset", scope.makeOpName("ShuffleAndRepeatDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(seed2.asOutput());
-    opBuilder.addInput(count.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(seed2.asOutput(scope));
+    opBuilder.addInput(count.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -86,8 +86,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 0b49950ee76..1401683e34f 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class ShuffleDataset extends RawOp implements Operand<Tensor> {
+public final class ShuffleDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ShuffleDataset operation.
@@ -49,9 +49,9 @@ public final class ShuffleDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static ShuffleDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> bufferSize, Operand<?> seedGenerator, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ShuffleDatasetV2", scope.makeOpName("ShuffleDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
-    opBuilder.addInput(seedGenerator.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
+    opBuilder.addInput(seedGenerator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -74,8 +74,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 ef55406b9e3..e114aa1c5bf 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that skips `count` elements from the `input_dataset`.
  */
 @Operator(group = "data")
-public final class SkipDataset extends RawOp implements Operand<Tensor> {
+public final class SkipDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SkipDataset operation.
@@ -51,8 +51,8 @@ public final class SkipDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static SkipDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> count, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("SkipDataset", scope.makeOpName("SkipDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(count.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(count.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 feeb78b77ed..d9e12b029d3 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SleepDataset extends RawOp implements Operand<Tensor> {
+public final class SleepDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SleepDataset operation.
@@ -48,8 +48,8 @@ public final class SleepDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static SleepDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> sleepMicroseconds, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("SleepDataset", scope.makeOpName("SleepDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(sleepMicroseconds.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(sleepMicroseconds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 305152de904..a0362984adb 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that passes a sliding window over `input_dataset`.
  */
-public final class SlidingWindowDataset extends RawOp implements Operand<Tensor> {
+public final class SlidingWindowDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SlidingWindowDataset operation.
@@ -54,10 +54,10 @@ public final class SlidingWindowDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static SlidingWindowDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> windowSize, Operand<TInt64> windowShift, Operand<TInt64> windowStride, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("SlidingWindowDataset", scope.makeOpName("SlidingWindowDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(windowSize.asOutput());
-    opBuilder.addInput(windowShift.asOutput());
-    opBuilder.addInput(windowStride.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(windowSize.asOutput(scope));
+    opBuilder.addInput(windowShift.asOutput(scope));
+    opBuilder.addInput(windowStride.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -80,8 +80,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 042a681eb8c..5cf1fc5873b 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that will write to / read from a snapshot.
@@ -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 RawOp implements Operand<Tensor> {
+public final class SnapshotDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.SnapshotDataset}
@@ -191,8 +191,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static SnapshotDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> path, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SnapshotDataset", scope.makeOpName("SnapshotDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(path.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(path.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -359,8 +359,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 e16be890f5e..911419a64ba 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that splits a SparseTensor into elements row-wise.
  */
-public final class SparseTensorSliceDataset extends RawOp implements Operand<Tensor> {
+public final class SparseTensorSliceDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorSliceDataset operation.
@@ -43,11 +43,11 @@ public final class SparseTensorSliceDataset extends RawOp implements Operand<Ten
    * @return a new instance of SparseTensorSliceDataset
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseTensorSliceDataset create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
+  public static <T extends TType> SparseTensorSliceDataset create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorSliceDataset", scope.makeOpName("SparseTensorSliceDataset"));
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(values.asOutput());
-    opBuilder.addInput(denseShape.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
+    opBuilder.addInput(denseShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseTensorSliceDataset(opBuilder.build());
   }
@@ -60,8 +60,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 b08bbaa8bd7..2df82612c50 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that executes a SQL query and emits rows of the result set.
  */
-public final class SqlDataset extends RawOp implements Operand<Tensor> {
+public final class SqlDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SqlDataset operation.
@@ -50,9 +50,9 @@ public final class SqlDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static SqlDataset create(Scope scope, Operand<TString> driverName, Operand<TString> dataSourceName, Operand<TString> query, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("SqlDataset", scope.makeOpName("SqlDataset"));
-    opBuilder.addInput(driverName.asOutput());
-    opBuilder.addInput(dataSourceName.asOutput());
-    opBuilder.addInput(query.asOutput());
+    opBuilder.addInput(driverName.asOutput(scope));
+    opBuilder.addInput(dataSourceName.asOutput(scope));
+    opBuilder.addInput(query.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 57bc572a7d3..7bb5c823219 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a statistics manager resource.
  */
-public final class StatsAggregatorHandle extends RawOp implements Operand<Tensor> {
+public final class StatsAggregatorHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.StatsAggregatorHandle}
@@ -106,8 +106,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 90e1a5c649a..0cf2c0d99d9 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains `count` elements from the `input_dataset`.
  */
 @Operator(group = "data")
-public final class TakeDataset extends RawOp implements Operand<Tensor> {
+public final class TakeDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TakeDataset operation.
@@ -52,8 +52,8 @@ public final class TakeDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static TakeDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> count, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("TakeDataset", scope.makeOpName("TakeDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(count.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(count.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 bfe55bbef91..808b1f8c673 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
@@ -22,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits `components` as a tuple of tensors once.
  */
-public final class TensorDataset extends RawOp implements Operand<Tensor> {
+public final class TensorDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorDataset operation.
@@ -46,7 +46,7 @@ public final class TensorDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static TensorDataset create(Scope scope, Iterable<Operand<?>> components, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorDataset", scope.makeOpName("TensorDataset"));
-    opBuilder.addInputList(Operands.asOutputs(components));
+    opBuilder.addInputList(Operands.asOutputs(scope, components));
     opBuilder = scope.applyControlDependencies(opBuilder);
     Shape[] outputShapesArray = new Shape[outputShapes.size()];
     for (int i = 0; i < outputShapesArray.length; ++i) {
@@ -64,8 +64,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 b0b69240a8d..ac393b022da 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
@@ -22,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits each dim-0 slice of `components` once.
  */
 @Operator(group = "data")
-public final class TensorSliceDataset extends RawOp implements Operand<Tensor> {
+public final class TensorSliceDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TensorSliceDataset operation.
@@ -47,7 +47,7 @@ public final class TensorSliceDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static TensorSliceDataset create(Scope scope, Iterable<Operand<?>> components, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorSliceDataset", scope.makeOpName("TensorSliceDataset"));
-    opBuilder.addInputList(Operands.asOutputs(components));
+    opBuilder.addInputList(Operands.asOutputs(scope, components));
     opBuilder = scope.applyControlDependencies(opBuilder);
     Shape[] outputShapesArray = new Shape[outputShapes.size()];
     for (int i = 0; i < outputShapesArray.length; ++i) {
@@ -65,8 +65,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 08fe2c10873..1b1339a271b 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the lines of one or more text files.
  */
 @Operator(group = "data")
-public final class TextLineDataset extends RawOp implements Operand<Tensor> {
+public final class TextLineDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TextLineDataset operation.
@@ -49,9 +49,9 @@ public final class TextLineDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static TextLineDataset create(Scope scope, Operand<TString> filenames, Operand<TString> compressionType, Operand<TInt64> bufferSize) {
     OperationBuilder opBuilder = scope.env().opBuilder("TextLineDataset", scope.makeOpName("TextLineDataset"));
-    opBuilder.addInput(filenames.asOutput());
-    opBuilder.addInput(compressionType.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
+    opBuilder.addInput(filenames.asOutput(scope));
+    opBuilder.addInput(compressionType.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TextLineDataset(opBuilder.build());
   }
@@ -64,8 +64,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 597734ace78..0e968b87686 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,19 +21,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that emits the records from one or more TFRecord files.
  */
 @Operator(group = "data")
-public final class TfRecordDataset extends RawOp implements Operand<Tensor> {
+public final class TfRecordDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new TfRecordDataset operation.
@@ -50,9 +50,9 @@ public final class TfRecordDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static TfRecordDataset create(Scope scope, Operand<TString> filenames, Operand<TString> compressionType, Operand<TInt64> bufferSize) {
     OperationBuilder opBuilder = scope.env().opBuilder("TFRecordDataset", scope.makeOpName("TfRecordDataset"));
-    opBuilder.addInput(filenames.asOutput());
-    opBuilder.addInput(compressionType.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
+    opBuilder.addInput(filenames.asOutput(scope));
+    opBuilder.addInput(compressionType.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TfRecordDataset(opBuilder.build());
   }
@@ -65,8 +65,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 3903f3153a7..5bc47af030d 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolDataset extends RawOp implements Operand<Tensor> {
+public final class ThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ThreadPoolDataset operation.
@@ -48,8 +48,8 @@ public final class ThreadPoolDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static ThreadPoolDataset create(Scope scope, Operand<?> inputDataset, Operand<?> threadPool, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ThreadPoolDataset", scope.makeOpName("ThreadPoolDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(threadPool.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(threadPool.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 ae10874ecb4..b10e3c76935 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolHandle extends RawOp implements Operand<Tensor> {
+public final class ThreadPoolHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.ThreadPoolHandle}
@@ -135,8 +135,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 90a4e50f409..91e21a2a32d 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A dataset that splits the elements of its input into multiple elements.
  */
-public final class UnbatchDataset extends RawOp implements Operand<Tensor> {
+public final class UnbatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UnbatchDataset operation.
@@ -47,7 +47,7 @@ public final class UnbatchDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static UnbatchDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnbatchDataset", scope.makeOpName("UnbatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 24169fb9071..d076e5456b4 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the unique elements of `input_dataset`.
  */
-public final class UniqueDataset extends RawOp implements Operand<Tensor> {
+public final class UniqueDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UniqueDataset operation.
@@ -47,7 +47,7 @@ public final class UniqueDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static UniqueDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("UniqueDataset", scope.makeOpName("UniqueDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 7e2e628e463..5763eb45264 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class UnwrapDatasetVariant extends RawOp implements Operand<Tensor> {
+public final class UnwrapDatasetVariant extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UnwrapDatasetVariant operation.
@@ -41,7 +41,7 @@ public final class UnwrapDatasetVariant extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static UnwrapDatasetVariant create(Scope scope, Operand<?> inputHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnwrapDatasetVariant", scope.makeOpName("UnwrapDatasetVariant"));
-    opBuilder.addInput(inputHandle.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new UnwrapDatasetVariant(opBuilder.build());
   }
@@ -54,8 +54,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 29055c9d385..9c7c3042e0a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -31,6 +30,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  *   Combines (nests of) input elements into a dataset of (nests of) windows.
@@ -76,7 +76,7 @@
  *   - `tf.data.Dataset.from_tensor_slices({"a": range(4)}).window(2)`
  *     produces `{{"a": {0, 1}}, {"a": {2, 3}}}`
  */
-public final class WindowDataset extends RawOp implements Operand<Tensor> {
+public final class WindowDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new WindowDataset operation.
@@ -100,11 +100,11 @@ public final class WindowDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static WindowDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> size, Operand<TInt64> shift, Operand<TInt64> stride, Operand<TBool> dropRemainder, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("WindowDataset", scope.makeOpName("WindowDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(size.asOutput());
-    opBuilder.addInput(shift.asOutput());
-    opBuilder.addInput(stride.asOutput());
-    opBuilder.addInput(dropRemainder.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
+    opBuilder.addInput(shift.asOutput(scope));
+    opBuilder.addInput(stride.asOutput(scope));
+    opBuilder.addInput(dropRemainder.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -127,8 +127,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 e7a5c710b19..155a23aa49d 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class WrapDatasetVariant extends RawOp implements Operand<Tensor> {
+public final class WrapDatasetVariant extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new WrapDatasetVariant operation.
@@ -41,7 +41,7 @@ public final class WrapDatasetVariant extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static WrapDatasetVariant create(Scope scope, Operand<?> inputHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("WrapDatasetVariant", scope.makeOpName("WrapDatasetVariant"));
-    opBuilder.addInput(inputHandle.asOutput());
+    opBuilder.addInput(inputHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WrapDatasetVariant(opBuilder.build());
   }
@@ -54,8 +54,8 @@ public Output<?> outputHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) outputHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) outputHandle;
   }
   
   private Output<?> outputHandle;
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 94b80a1377d..51365e8db31 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
@@ -23,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that zips together `input_datasets`.
@@ -41,7 +41,7 @@
  * dataset, and no error will be raised if input datasets have different sizes.
  */
 @Operator(group = "data")
-public final class ZipDataset extends RawOp implements Operand<Tensor> {
+public final class ZipDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ZipDataset operation.
@@ -55,7 +55,7 @@ public final class ZipDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static ZipDataset create(Scope scope, Iterable<Operand<?>> inputDatasets, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ZipDataset", scope.makeOpName("ZipDataset"));
-    opBuilder.addInputList(Operands.asOutputs(inputDatasets));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputDatasets));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -78,8 +78,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java
index fbf3e3e53a8..b5fb8685fbb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/data/experimental/AssertCardinalityDataset.java
@@ -23,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class AssertCardinalityDataset extends RawOp implements Operand<Tensor> {
+public final class AssertCardinalityDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new AssertCardinalityDataset operation.
@@ -48,8 +48,8 @@ public final class AssertCardinalityDataset extends RawOp implements Operand<Ten
   @Endpoint(describeByClass = true)
   public static AssertCardinalityDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> cardinality, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("AssertCardinalityDataset", scope.makeOpName("AssertCardinalityDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(cardinality.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(cardinality.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 1ae871d4754..cd98aff52bb 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class AssertNextDataset extends RawOp implements Operand<Tensor> {
+public final class AssertNextDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new AssertNextDataset operation.
@@ -48,8 +48,8 @@ public final class AssertNextDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static AssertNextDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> transformations, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalAssertNextDataset", scope.makeOpName("AssertNextDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(transformations.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(transformations.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d88e8552f55..816889d42dd 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that shards the input dataset.
@@ -42,7 +42,7 @@
  * This dataset will throw a NotFound error if we cannot shard the dataset
  * automatically.
  */
-public final class AutoShardDataset extends RawOp implements Operand<Tensor> {
+public final class AutoShardDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.AutoShardDataset}
@@ -78,9 +78,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static AutoShardDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numWorkers, Operand<TInt64> index, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalAutoShardDataset", scope.makeOpName("AutoShardDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numWorkers.asOutput());
-    opBuilder.addInput(index.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numWorkers.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -117,8 +117,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 b82bab6d628..8b9e357c181 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Records the bytes size of each element of `input_dataset` in a StatsAggregator.
  */
-public final class BytesProducedStatsDataset extends RawOp implements Operand<Tensor> {
+public final class BytesProducedStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BytesProducedStatsDataset operation.
@@ -49,8 +49,8 @@ public final class BytesProducedStatsDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static BytesProducedStatsDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> tag, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalBytesProducedStatsDataset", scope.makeOpName("BytesProducedStatsDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(tag.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 31effddb334..56c88ee8593 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
@@ -22,7 +22,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -32,10 +31,11 @@
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class CSVDataset extends RawOp implements Operand<Tensor> {
+public final class CSVDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new CSVDataset operation.
@@ -56,15 +56,15 @@ public final class CSVDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static CSVDataset create(Scope scope, Operand<TString> filenames, Operand<TString> compressionType, Operand<TInt64> bufferSize, Operand<TBool> header, Operand<TString> fieldDelim, Operand<TBool> useQuoteDelim, Operand<TString> naValue, Operand<TInt64> selectCols, Iterable<Operand<?>> recordDefaults, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalCSVDataset", scope.makeOpName("CSVDataset"));
-    opBuilder.addInput(filenames.asOutput());
-    opBuilder.addInput(compressionType.asOutput());
-    opBuilder.addInput(bufferSize.asOutput());
-    opBuilder.addInput(header.asOutput());
-    opBuilder.addInput(fieldDelim.asOutput());
-    opBuilder.addInput(useQuoteDelim.asOutput());
-    opBuilder.addInput(naValue.asOutput());
-    opBuilder.addInput(selectCols.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(recordDefaults));
+    opBuilder.addInput(filenames.asOutput(scope));
+    opBuilder.addInput(compressionType.asOutput(scope));
+    opBuilder.addInput(bufferSize.asOutput(scope));
+    opBuilder.addInput(header.asOutput(scope));
+    opBuilder.addInput(fieldDelim.asOutput(scope));
+    opBuilder.addInput(useQuoteDelim.asOutput(scope));
+    opBuilder.addInput(naValue.asOutput(scope));
+    opBuilder.addInput(selectCols.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, recordDefaults));
     opBuilder = scope.applyControlDependencies(opBuilder);
     Shape[] outputShapesArray = new Shape[outputShapes.size()];
     for (int i = 0; i < outputShapesArray.length; ++i) {
@@ -82,8 +82,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 17323f95ef9..ec8498d1294 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
@@ -23,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class ChooseFastestDataset extends RawOp implements Operand<Tensor> {
+public final class ChooseFastestDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ChooseFastestDataset operation.
@@ -48,7 +48,7 @@ public final class ChooseFastestDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static ChooseFastestDataset create(Scope scope, Iterable<Operand<?>> inputDatasets, Long numExperiments, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalChooseFastestDataset", scope.makeOpName("ChooseFastestDataset"));
-    opBuilder.addInputList(Operands.asOutputs(inputDatasets));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputDatasets));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_experiments", numExperiments);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 290bec84df8..8c80587f4b4 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
@@ -44,7 +44,7 @@ public final class DatasetCardinality extends RawOp implements Operand<TInt64> {
   @Endpoint(describeByClass = true)
   public static DatasetCardinality create(Scope scope, Operand<?> inputDataset) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalDatasetCardinality", scope.makeOpName("DatasetCardinality"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DatasetCardinality(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TInt64> cardinality() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return cardinality;
   }
   
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 3bb2bc62b4b..efc3c5c6692 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
@@ -44,9 +44,9 @@ public final class DatasetToTFRecord extends RawOp {
   @Endpoint(describeByClass = true)
   public static DatasetToTFRecord create(Scope scope, Operand<?> inputDataset, Operand<TString> filename, Operand<TString> compressionType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalDatasetToTFRecord", scope.makeOpName("DatasetToTFRecord"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(filename.asOutput());
-    opBuilder.addInput(compressionType.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(filename.asOutput(scope));
+    opBuilder.addInput(compressionType.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DatasetToTFRecord(opBuilder.build());
   }
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 30d81e35490..e172458ca67 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that batches input elements into a SparseTensor.
  */
-public final class DenseToSparseBatchDataset extends RawOp implements Operand<Tensor> {
+public final class DenseToSparseBatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DenseToSparseBatchDataset operation.
@@ -53,9 +53,9 @@ public final class DenseToSparseBatchDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static DenseToSparseBatchDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> batchSize, Operand<TInt64> rowShape, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalDenseToSparseBatchDataset", scope.makeOpName("DenseToSparseBatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(batchSize.asOutput());
-    opBuilder.addInput(rowShape.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(batchSize.asOutput(scope));
+    opBuilder.addInput(rowShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -78,8 +78,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d33d1eae050..89f39d453d8 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
@@ -23,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
  */
-public final class DirectedInterleaveDataset extends RawOp implements Operand<Tensor> {
+public final class DirectedInterleaveDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DirectedInterleaveDataset operation.
@@ -51,8 +51,8 @@ public final class DirectedInterleaveDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static DirectedInterleaveDataset create(Scope scope, Operand<?> selectorInputDataset, Iterable<Operand<?>> dataInputDatasets, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalDirectedInterleaveDataset", scope.makeOpName("DirectedInterleaveDataset"));
-    opBuilder.addInput(selectorInputDataset.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(dataInputDatasets));
+    opBuilder.addInput(selectorInputDataset.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, dataInputDatasets));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 feb3d2ef49a..26f6a8535b6 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the elements of `input_dataset` ignoring errors.
  */
-public final class IgnoreErrorsDataset extends RawOp implements Operand<Tensor> {
+public final class IgnoreErrorsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new IgnoreErrorsDataset operation.
@@ -47,7 +47,7 @@ public final class IgnoreErrorsDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static IgnoreErrorsDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalIgnoreErrorsDataset", scope.makeOpName("IgnoreErrorsDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 2e19177a58f..014abc5504e 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
@@ -42,7 +42,7 @@ public final class IteratorGetDevice extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static IteratorGetDevice create(Scope scope, Operand<?> resource) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalIteratorGetDevice", scope.makeOpName("IteratorGetDevice"));
-    opBuilder.addInput(resource.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IteratorGetDevice(opBuilder.build());
   }
@@ -54,7 +54,7 @@ public Output<TString> device() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return device;
   }
   
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 fc0c6bdc53f..bfc8ce1d9e2 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Records the latency of producing `input_dataset` elements in a StatsAggregator.
  */
-public final class LatencyStatsDataset extends RawOp implements Operand<Tensor> {
+public final class LatencyStatsDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LatencyStatsDataset operation.
@@ -49,8 +49,8 @@ public final class LatencyStatsDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static LatencyStatsDataset create(Scope scope, Operand<?> inputDataset, Operand<TString> tag, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalLatencyStatsDataset", scope.makeOpName("LatencyStatsDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(tag.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 cdd23b3bd0b..4f6a784df1c 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class LmdbDataset extends RawOp implements Operand<Tensor> {
+public final class LmdbDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new LmdbDataset operation.
@@ -47,7 +47,7 @@ public final class LmdbDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static LmdbDataset create(Scope scope, Operand<TString> filenames, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalLMDBDataset", scope.makeOpName("LmdbDataset"));
-    opBuilder.addInput(filenames.asOutput());
+    opBuilder.addInput(filenames.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 a076417c9e2..04f7b4757d3 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class MatchingFilesDataset extends RawOp implements Operand<Tensor> {
+public final class MatchingFilesDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MatchingFilesDataset operation.
@@ -42,7 +42,7 @@ public final class MatchingFilesDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static MatchingFilesDataset create(Scope scope, Operand<TString> patterns) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalMatchingFilesDataset", scope.makeOpName("MatchingFilesDataset"));
-    opBuilder.addInput(patterns.asOutput());
+    opBuilder.addInput(patterns.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MatchingFilesDataset(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 258c75040a4..d8160a70d31 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that overrides the maximum intra-op parallelism.
  */
-public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<Tensor> {
+public final class MaxIntraOpParallelismDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new MaxIntraOpParallelismDataset operation.
@@ -49,8 +49,8 @@ public final class MaxIntraOpParallelismDataset extends RawOp implements Operand
   @Endpoint(describeByClass = true)
   public static MaxIntraOpParallelismDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> maxIntraOpParallelism, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalMaxIntraOpParallelismDataset", scope.makeOpName("MaxIntraOpParallelismDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(maxIntraOpParallelism.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(maxIntraOpParallelism.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 2dfdfd270c3..60de23547c3 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,16 +23,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class NonSerializableDataset extends RawOp implements Operand<Tensor> {
+public final class NonSerializableDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new NonSerializableDataset operation.
@@ -46,7 +46,7 @@ public final class NonSerializableDataset extends RawOp implements Operand<Tenso
   @Endpoint(describeByClass = true)
   public static NonSerializableDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalNonSerializableDataset", scope.makeOpName("NonSerializableDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -69,8 +69,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 1d0c6f31faa..1e1a7041a03 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
@@ -23,7 +23,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
@@ -31,12 +30,12 @@
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
-import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * 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 RawOp implements Operand<Tensor> {
+public final class ParseExampleDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.ParseExampleDataset}
@@ -104,9 +103,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ParseExampleDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numParallelCalls, Iterable<Operand<?>> denseDefaults, List<String> sparseKeys, List<String> denseKeys, List<DataType<?>> sparseTypes, List<Shape> denseShapes, List<DataType<?>> outputTypes, List<Shape> outputShapes, List<DataType<?>> raggedValueTypes, List<DataType<?>> raggedSplitTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParseExampleDatasetV2", scope.makeOpName("ParseExampleDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numParallelCalls.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(denseDefaults));
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numParallelCalls.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, denseDefaults));
     opBuilder = scope.applyControlDependencies(opBuilder);
     String[] sparseKeysArray = new String[sparseKeys.size()];
     for (int i = 0; i < sparseKeysArray.length; ++i) {
@@ -191,8 +190,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 2648fed52e9..82c5b923ad6 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class PrivateThreadPoolDataset extends RawOp implements Operand<Tensor> {
+public final class PrivateThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new PrivateThreadPoolDataset operation.
@@ -49,8 +49,8 @@ public final class PrivateThreadPoolDataset extends RawOp implements Operand<Ten
   @Endpoint(describeByClass = true)
   public static PrivateThreadPoolDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numThreads, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalPrivateThreadPoolDataset", scope.makeOpName("PrivateThreadPoolDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numThreads.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numThreads.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -73,8 +73,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 7035aec9273..75b9531cda0 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a Dataset that returns pseudorandom numbers.
  */
-public final class RandomDataset extends RawOp implements Operand<Tensor> {
+public final class RandomDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RandomDataset operation.
@@ -51,8 +51,8 @@ public final class RandomDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static RandomDataset create(Scope scope, Operand<TInt64> seed, Operand<TInt64> seed2, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalRandomDataset", scope.makeOpName("RandomDataset"));
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(seed2.asOutput());
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(seed2.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 31d5cf4200c..9f3dedc93af 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,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that changes the batch size.
@@ -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 RawOp implements Operand<Tensor> {
+public final class RebatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.RebatchDataset}
@@ -74,8 +74,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static RebatchDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> numReplicas, List<DataType<?>> outputTypes, List<Shape> outputShapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalRebatchDataset", scope.makeOpName("RebatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(numReplicas.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(numReplicas.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -112,8 +112,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 62657afba76..368a8fcf6c6 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SetStatsAggregatorDataset extends RawOp implements Operand<Tensor> {
+public final class SetStatsAggregatorDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SetStatsAggregatorDataset operation.
@@ -50,10 +50,10 @@ public final class SetStatsAggregatorDataset extends RawOp implements Operand<Te
   @Endpoint(describeByClass = true)
   public static SetStatsAggregatorDataset create(Scope scope, Operand<?> inputDataset, Operand<?> statsAggregator, Operand<TString> tag, Operand<TString> counterPrefix, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalSetStatsAggregatorDataset", scope.makeOpName("SetStatsAggregatorDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(statsAggregator.asOutput());
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(counterPrefix.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(statsAggregator.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(counterPrefix.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -76,8 +76,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 939bf3951db..9bf865c5f15 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SleepDataset extends RawOp implements Operand<Tensor> {
+public final class SleepDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SleepDataset operation.
@@ -48,8 +48,8 @@ public final class SleepDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static SleepDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> sleepMicroseconds, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalSleepDataset", scope.makeOpName("SleepDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(sleepMicroseconds.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(sleepMicroseconds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 617ea5204f9..f7e7b55b243 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that passes a sliding window over `input_dataset`.
  */
-public final class SlidingWindowDataset extends RawOp implements Operand<Tensor> {
+public final class SlidingWindowDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SlidingWindowDataset operation.
@@ -54,10 +54,10 @@ public final class SlidingWindowDataset extends RawOp implements Operand<Tensor>
   @Endpoint(describeByClass = true)
   public static SlidingWindowDataset create(Scope scope, Operand<?> inputDataset, Operand<TInt64> windowSize, Operand<TInt64> windowShift, Operand<TInt64> windowStride, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalSlidingWindowDataset", scope.makeOpName("SlidingWindowDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(windowSize.asOutput());
-    opBuilder.addInput(windowShift.asOutput());
-    opBuilder.addInput(windowStride.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(windowSize.asOutput(scope));
+    opBuilder.addInput(windowShift.asOutput(scope));
+    opBuilder.addInput(windowStride.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -80,8 +80,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 1bc4612a6ea..18bc863ae5a 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that executes a SQL query and emits rows of the result set.
  */
-public final class SqlDataset extends RawOp implements Operand<Tensor> {
+public final class SqlDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SqlDataset operation.
@@ -50,9 +50,9 @@ public final class SqlDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static SqlDataset create(Scope scope, Operand<TString> driverName, Operand<TString> dataSourceName, Operand<TString> query, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalSqlDataset", scope.makeOpName("SqlDataset"));
-    opBuilder.addInput(driverName.asOutput());
-    opBuilder.addInput(dataSourceName.asOutput());
-    opBuilder.addInput(query.asOutput());
+    opBuilder.addInput(driverName.asOutput(scope));
+    opBuilder.addInput(dataSourceName.asOutput(scope));
+    opBuilder.addInput(query.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -75,8 +75,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 7c1d95e7966..818ed60f38a 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class StatsAggregatorHandle extends RawOp implements Operand<Tensor> {
+public final class StatsAggregatorHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.StatsAggregatorHandle}
@@ -105,8 +105,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 44acd09f14c..7bafeaf6632 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
@@ -41,8 +41,8 @@ public final class StatsAggregatorSetSummaryWriter extends RawOp {
   @Endpoint(describeByClass = true)
   public static StatsAggregatorSetSummaryWriter create(Scope scope, Operand<?> statsAggregator, Operand<?> summary) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatsAggregatorSetSummaryWriter", scope.makeOpName("StatsAggregatorSetSummaryWriter"));
-    opBuilder.addInput(statsAggregator.asOutput());
-    opBuilder.addInput(summary.asOutput());
+    opBuilder.addInput(statsAggregator.asOutput(scope));
+    opBuilder.addInput(summary.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new StatsAggregatorSetSummaryWriter(opBuilder.build());
   }
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 1a4d285dfe3..507d740558e 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
@@ -42,7 +42,7 @@ public final class StatsAggregatorSummary extends RawOp implements Operand<TStri
   @Endpoint(describeByClass = true)
   public static StatsAggregatorSummary create(Scope scope, Operand<?> iterator) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalStatsAggregatorSummary", scope.makeOpName("StatsAggregatorSummary"));
-    opBuilder.addInput(iterator.asOutput());
+    opBuilder.addInput(iterator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new StatsAggregatorSummary(opBuilder.build());
   }
@@ -54,7 +54,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 d05b207806e..3cbf8c81b6e 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolDataset extends RawOp implements Operand<Tensor> {
+public final class ThreadPoolDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new ThreadPoolDataset operation.
@@ -48,8 +48,8 @@ public final class ThreadPoolDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static ThreadPoolDataset create(Scope scope, Operand<?> inputDataset, Operand<?> threadPool, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalThreadPoolDataset", scope.makeOpName("ThreadPoolDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
-    opBuilder.addInput(threadPool.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
+    opBuilder.addInput(threadPool.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -72,8 +72,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 ee2a5f0c5c3..239ef8ce600 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that uses a custom thread pool to compute `input_dataset`.
  */
-public final class ThreadPoolHandle extends RawOp implements Operand<Tensor> {
+public final class ThreadPoolHandle extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.data.experimental.ThreadPoolHandle}
@@ -135,8 +135,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 94fec642de9..881ebf9c772 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A dataset that splits the elements of its input into multiple elements.
  */
-public final class UnbatchDataset extends RawOp implements Operand<Tensor> {
+public final class UnbatchDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UnbatchDataset operation.
@@ -47,7 +47,7 @@ public final class UnbatchDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static UnbatchDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalUnbatchDataset", scope.makeOpName("UnbatchDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 049d4b64211..a67d2733d18 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a dataset that contains the unique elements of `input_dataset`.
  */
-public final class UniqueDataset extends RawOp implements Operand<Tensor> {
+public final class UniqueDataset extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new UniqueDataset operation.
@@ -47,7 +47,7 @@ public final class UniqueDataset extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static UniqueDataset create(Scope scope, Operand<?> inputDataset, List<DataType<?>> outputTypes, List<Shape> outputShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExperimentalUniqueDataset", scope.makeOpName("UniqueDataset"));
-    opBuilder.addInput(inputDataset.asOutput());
+    opBuilder.addInput(inputDataset.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] outputTypesArray = new DataType[outputTypes.size()];
     for (int i = 0; i < outputTypesArray.length; ++i) {
@@ -70,8 +70,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java
index 1735b281db5..fef0882267a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/CheckNumerics.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CheckNumerics<T extends Tensor & TNumber> extends RawOp 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.
@@ -49,9 +48,9 @@ public final class CheckNumerics<T extends Tensor & TNumber> extends RawOp imple
    * @return a new instance of CheckNumerics
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CheckNumerics<T> create(Scope scope, Operand<T> tensor, String message) {
+  public static <T extends TNumber> CheckNumerics<T> create(Scope scope, Operand<T> tensor, String message) {
     OperationBuilder opBuilder = scope.env().opBuilder("CheckNumericsV2", scope.makeOpName("CheckNumerics"));
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("message", message);
     return new CheckNumerics<T>(opBuilder.build());
@@ -64,7 +63,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java
index b574bf74b0f..161b05d7e7b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientIdentity.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Identity op for gradient debugging.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugGradientIdentity<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class DebugGradientIdentity<T extends Tensor> extends RawOp impleme
    * @return a new instance of DebugGradientIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DebugGradientIdentity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> DebugGradientIdentity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugGradientIdentity", scope.makeOpName("DebugGradientIdentity"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DebugGradientIdentity<T>(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java
index bd2fa8bc59c..c187920fd57 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugGradientRefIdentity.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Identity op for gradient debugging.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugGradientRefIdentity<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class DebugGradientRefIdentity<T extends Tensor> extends RawOp impl
    * @return a new instance of DebugGradientRefIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DebugGradientRefIdentity<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> DebugGradientRefIdentity<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugGradientRefIdentity", scope.makeOpName("DebugGradientRefIdentity"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DebugGradientRefIdentity<T>(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java
index 3682b5b1707..823f839bba6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugIdentity.java
@@ -22,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Debug Identity V2 Op.
@@ -43,7 +43,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class DebugIdentity<T extends Tensor> extends RawOp implements Operand<T> {
+public final class DebugIdentity<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.debugging.DebugIdentity}
@@ -112,9 +112,9 @@ private Options() {
    * @return a new instance of DebugIdentity
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DebugIdentity<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> DebugIdentity<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugIdentityV2", scope.makeOpName("DebugIdentity"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -187,7 +187,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java
index a35b06da0ff..c5653b1d6cb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNanCount.java
@@ -22,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Debug NaN Value Counter Op.
@@ -97,9 +97,9 @@ private Options() {
    * @return a new instance of DebugNanCount
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DebugNanCount create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> DebugNanCount create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugNanCount", scope.makeOpName("DebugNanCount"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -165,7 +165,7 @@ public Output<TInt64> output() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java
index 6c1e2845eac..08a17016b43 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/debugging/DebugNumericsSummary.java
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Debug Numeric Summary V2 Op.
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class DebugNumericsSummary<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class DebugNumericsSummary<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.debugging.DebugNumericsSummary}
@@ -132,9 +132,9 @@ private Options() {
    * @return a new instance of DebugNumericsSummary
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> DebugNumericsSummary<U> create(Scope scope, Operand<T> input, DataType<U> outputDtype, Options... options) {
+  public static <U extends TNumber, T extends TType> DebugNumericsSummary<U> create(Scope scope, Operand<T> input, DataType<U> outputDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DebugNumericSummaryV2", scope.makeOpName("DebugNumericsSummary"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_dtype", outputDtype);
     if (options != null) {
@@ -159,7 +159,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> DebugNumericsSummar
    * @return a new instance of DebugNumericsSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DebugNumericsSummary<TFloat32> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> DebugNumericsSummary<TFloat32> create(Scope scope, Operand<T> input, Options... options) {
     return create(scope, input, TFloat32.DTYPE, options);
   }
   
@@ -237,7 +237,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 56aaf980151..645d0d9e034 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts each entry in the given tensor to strings.
@@ -116,9 +116,9 @@ private Options() {
    * @return a new instance of AsString
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AsString create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> AsString create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AsString", scope.makeOpName("AsString"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -189,7 +189,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 d73b540c918..c1e56d64237 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Cast x of type SrcT to y of DstT.
@@ -34,7 +34,7 @@
  * @param <U> data type for {@code y()} output
  */
 @Operator(group = "dtypes")
-public final class Cast<U extends Tensor> extends RawOp implements Operand<U> {
+public final class Cast<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.dtypes.Cast}
@@ -65,9 +65,9 @@ private Options() {
    * @return a new instance of Cast
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> Cast<U> create(Scope scope, Operand<T> x, DataType<U> DstT, Options... options) {
+  public static <U extends TType, T extends TType> Cast<U> create(Scope scope, Operand<T> x, DataType<U> DstT, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cast", scope.makeOpName("Cast"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("DstT", DstT);
     if (options != null) {
@@ -94,7 +94,7 @@ public Output<U> y() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return y;
   }
   
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 634b4167b74..5a68610b28f 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts two real numbers to a complex number.
@@ -50,7 +50,7 @@
  * @param <U> data type for {@code out()} output
  */
 @Operator(group = "dtypes")
-public final class Complex<U extends Tensor> extends RawOp 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.
@@ -62,10 +62,10 @@ public final class Complex<U extends Tensor> extends RawOp implements Operand<U>
    * @return a new instance of Complex
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> Complex<U> create(Scope scope, Operand<T> real, Operand<T> imag, DataType<U> Tout) {
+  public static <U extends TType, T extends TNumber> Complex<U> create(Scope scope, Operand<T> real, Operand<T> imag, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Complex", scope.makeOpName("Complex"));
-    opBuilder.addInput(real.asOutput());
-    opBuilder.addInput(imag.asOutput());
+    opBuilder.addInput(real.asOutput(scope));
+    opBuilder.addInput(imag.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tout", Tout);
     return new Complex<U>(opBuilder.build());
@@ -78,7 +78,7 @@ public Output<U> out() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return out;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java
index c27a1f57cfc..59f0684d400 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/dtypes/ToBool.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts a tensor to a scalar predicate.
@@ -54,9 +54,9 @@ public final class ToBool extends RawOp implements Operand<TBool> {
    * @return a new instance of ToBool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ToBool create(Scope scope, Operand<T> input) {
+  public static <T extends TType> ToBool create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("ToBool", scope.makeOpName("ToBool"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ToBool(opBuilder.build());
   }
@@ -68,7 +68,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 8a89bc639ba..33caeb9e658 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
@@ -50,10 +50,10 @@ public final class BoostedTreesAggregateStats extends RawOp implements Operand<T
   @Endpoint(describeByClass = true)
   public static BoostedTreesAggregateStats create(Scope scope, Operand<TInt32> nodeIds, Operand<TFloat32> gradients, Operand<TFloat32> hessians, Operand<TInt32> feature, Long maxSplits, Long numBuckets) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesAggregateStats", scope.makeOpName("BoostedTreesAggregateStats"));
-    opBuilder.addInput(nodeIds.asOutput());
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(hessians.asOutput());
-    opBuilder.addInput(feature.asOutput());
+    opBuilder.addInput(nodeIds.asOutput(scope));
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(hessians.asOutput(scope));
+    opBuilder.addInput(feature.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("max_splits", maxSplits);
     opBuilder.setAttr("num_buckets", numBuckets);
@@ -69,7 +69,7 @@ public Output<TFloat32> statsSummary() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return statsSummary;
   }
   
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 1af298bc2c1..93e735ed33c 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
@@ -52,8 +52,8 @@ public final class BoostedTreesBucketize extends RawOp implements Iterable<Opera
   @Endpoint(describeByClass = true)
   public static BoostedTreesBucketize create(Scope scope, Iterable<Operand<TFloat32>> floatValues, Iterable<Operand<TFloat32>> bucketBoundaries) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesBucketize", scope.makeOpName("BoostedTreesBucketize"));
-    opBuilder.addInputList(Operands.asOutputs(floatValues));
-    opBuilder.addInputList(Operands.asOutputs(bucketBoundaries));
+    opBuilder.addInputList(Operands.asOutputs(scope, floatValues));
+    opBuilder.addInputList(Operands.asOutputs(scope, bucketBoundaries));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesBucketize(opBuilder.build());
   }
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 20de330cd53..fa794603578 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
@@ -79,12 +79,12 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BoostedTreesCalculateBestFeatureSplit create(Scope scope, Operand<TInt32> nodeIdRange, Operand<TFloat32> statsSummary, Operand<TFloat32> l1, Operand<TFloat32> l2, Operand<TFloat32> treeComplexity, Operand<TFloat32> minNodeWeight, Long logitsDimension, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesCalculateBestFeatureSplit", scope.makeOpName("BoostedTreesCalculateBestFeatureSplit"));
-    opBuilder.addInput(nodeIdRange.asOutput());
-    opBuilder.addInput(statsSummary.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(treeComplexity.asOutput());
-    opBuilder.addInput(minNodeWeight.asOutput());
+    opBuilder.addInput(nodeIdRange.asOutput(scope));
+    opBuilder.addInput(statsSummary.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(treeComplexity.asOutput(scope));
+    opBuilder.addInput(minNodeWeight.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("logits_dimension", logitsDimension);
     if (options != null) {
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplitV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplitV2.java
index 69fe748a5cd..3873bc4dceb 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplitV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/estimator/BoostedTreesCalculateBestFeatureSplitV2.java
@@ -62,14 +62,14 @@ public final class BoostedTreesCalculateBestFeatureSplitV2 extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesCalculateBestFeatureSplitV2 create(Scope scope, Operand<TInt32> nodeIdRange, Iterable<Operand<TFloat32>> statsSummariesList, Operand<TString> splitTypes, Operand<TInt32> candidateFeatureIds, Operand<TFloat32> l1, Operand<TFloat32> l2, Operand<TFloat32> treeComplexity, Operand<TFloat32> minNodeWeight, Long logitsDimension) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesCalculateBestFeatureSplitV2", scope.makeOpName("BoostedTreesCalculateBestFeatureSplitV2"));
-    opBuilder.addInput(nodeIdRange.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(statsSummariesList));
-    opBuilder.addInput(splitTypes.asOutput());
-    opBuilder.addInput(candidateFeatureIds.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(treeComplexity.asOutput());
-    opBuilder.addInput(minNodeWeight.asOutput());
+    opBuilder.addInput(nodeIdRange.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, statsSummariesList));
+    opBuilder.addInput(splitTypes.asOutput(scope));
+    opBuilder.addInput(candidateFeatureIds.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(treeComplexity.asOutput(scope));
+    opBuilder.addInput(minNodeWeight.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("logits_dimension", logitsDimension);
     return new BoostedTreesCalculateBestFeatureSplitV2(opBuilder.build());
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 fdf87628efb..c033e8951f0 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
@@ -61,12 +61,12 @@ public final class BoostedTreesCalculateBestGainsPerFeature extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesCalculateBestGainsPerFeature create(Scope scope, Operand<TInt32> nodeIdRange, Iterable<Operand<TFloat32>> statsSummaryList, Operand<TFloat32> l1, Operand<TFloat32> l2, Operand<TFloat32> treeComplexity, Operand<TFloat32> minNodeWeight, Long maxSplits) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesCalculateBestGainsPerFeature", scope.makeOpName("BoostedTreesCalculateBestGainsPerFeature"));
-    opBuilder.addInput(nodeIdRange.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(statsSummaryList));
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(treeComplexity.asOutput());
-    opBuilder.addInput(minNodeWeight.asOutput());
+    opBuilder.addInput(nodeIdRange.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, statsSummaryList));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(treeComplexity.asOutput(scope));
+    opBuilder.addInput(minNodeWeight.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("max_splits", maxSplits);
     return new BoostedTreesCalculateBestGainsPerFeature(opBuilder.build());
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 e1af20a1f14..82e9e00e143 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
@@ -47,11 +47,11 @@ public final class BoostedTreesCenterBias extends RawOp implements Operand<TBool
   @Endpoint(describeByClass = true)
   public static BoostedTreesCenterBias create(Scope scope, Operand<?> treeEnsembleHandle, Operand<TFloat32> meanGradients, Operand<TFloat32> meanHessians, Operand<TFloat32> l1, Operand<TFloat32> l2) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesCenterBias", scope.makeOpName("BoostedTreesCenterBias"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInput(meanGradients.asOutput());
-    opBuilder.addInput(meanHessians.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInput(meanGradients.asOutput(scope));
+    opBuilder.addInput(meanHessians.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesCenterBias(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<TBool> continueCentering() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return continueCentering;
   }
   
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 c0c9075f784..57e2fb0d4e2 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
@@ -44,9 +44,9 @@ public final class BoostedTreesCreateEnsemble extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesCreateEnsemble create(Scope scope, Operand<?> treeEnsembleHandle, Operand<TInt64> stampToken, Operand<TString> treeEnsembleSerialized) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesCreateEnsemble", scope.makeOpName("BoostedTreesCreateEnsemble"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInput(stampToken.asOutput());
-    opBuilder.addInput(treeEnsembleSerialized.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInput(stampToken.asOutput(scope));
+    opBuilder.addInput(treeEnsembleSerialized.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesCreateEnsemble(opBuilder.build());
   }
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 d0ac0b0224d..ff0fb85b925 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
@@ -64,9 +64,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BoostedTreesCreateQuantileStreamResource create(Scope scope, Operand<?> quantileStreamResourceHandle, Operand<TFloat32> epsilon, Operand<TInt64> numStreams, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesCreateQuantileStreamResource", scope.makeOpName("BoostedTreesCreateQuantileStreamResource"));
-    opBuilder.addInput(quantileStreamResourceHandle.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(numStreams.asOutput());
+    opBuilder.addInput(quantileStreamResourceHandle.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(numStreams.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 8780ca997bd..2280be3a1c1 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
@@ -46,9 +46,9 @@ public final class BoostedTreesDeserializeEnsemble extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesDeserializeEnsemble create(Scope scope, Operand<?> treeEnsembleHandle, Operand<TInt64> stampToken, Operand<TString> treeEnsembleSerialized) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesDeserializeEnsemble", scope.makeOpName("BoostedTreesDeserializeEnsemble"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInput(stampToken.asOutput());
-    opBuilder.addInput(treeEnsembleSerialized.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInput(stampToken.asOutput(scope));
+    opBuilder.addInput(treeEnsembleSerialized.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesDeserializeEnsemble(opBuilder.build());
   }
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 83525b35fab..8f2f7b8aa41 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a BoostedTreesEnsembleResource
  */
-public final class BoostedTreesEnsembleResourceHandleOp extends RawOp implements Operand<Tensor> {
+public final class BoostedTreesEnsembleResourceHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesEnsembleResourceHandleOp}
@@ -106,8 +106,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) resource;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) resource;
   }
   
   private Output<?> resource;
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 4902a23c9eb..336ad889335 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
@@ -52,8 +52,8 @@ public final class BoostedTreesExampleDebugOutputs extends RawOp implements Oper
   @Endpoint(describeByClass = true)
   public static BoostedTreesExampleDebugOutputs create(Scope scope, Operand<?> treeEnsembleHandle, Iterable<Operand<TInt32>> bucketizedFeatures, Long logitsDimension) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesExampleDebugOutputs", scope.makeOpName("BoostedTreesExampleDebugOutputs"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(bucketizedFeatures));
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, bucketizedFeatures));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("logits_dimension", logitsDimension);
     return new BoostedTreesExampleDebugOutputs(opBuilder.build());
@@ -67,7 +67,7 @@ public Output<TString> examplesDebugOutputsSerialized() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return examplesDebugOutputsSerialized;
   }
   
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 d520766a041..593dc4f0722 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
@@ -50,7 +50,7 @@ public final class BoostedTreesFlushQuantileSummaries extends RawOp implements I
   @Endpoint(describeByClass = true)
   public static BoostedTreesFlushQuantileSummaries create(Scope scope, Operand<?> quantileStreamResourceHandle, Long numFeatures) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesFlushQuantileSummaries", scope.makeOpName("BoostedTreesFlushQuantileSummaries"));
-    opBuilder.addInput(quantileStreamResourceHandle.asOutput());
+    opBuilder.addInput(quantileStreamResourceHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_features", numFeatures);
     return new BoostedTreesFlushQuantileSummaries(opBuilder.build());
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 06ef0f63bfc..ced2a5449eb 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
@@ -43,7 +43,7 @@ public final class BoostedTreesGetEnsembleStates extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesGetEnsembleStates create(Scope scope, Operand<?> treeEnsembleHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesGetEnsembleStates", scope.makeOpName("BoostedTreesGetEnsembleStates"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesGetEnsembleStates(opBuilder.build());
   }
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 6bdbd64dd7a..f8e750db50a 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
@@ -51,9 +51,9 @@ public final class BoostedTreesMakeQuantileSummaries extends RawOp implements It
   @Endpoint(describeByClass = true)
   public static BoostedTreesMakeQuantileSummaries create(Scope scope, Iterable<Operand<TFloat32>> floatValues, Operand<TFloat32> exampleWeights, Operand<TFloat32> epsilon) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesMakeQuantileSummaries", scope.makeOpName("BoostedTreesMakeQuantileSummaries"));
-    opBuilder.addInputList(Operands.asOutputs(floatValues));
-    opBuilder.addInput(exampleWeights.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, floatValues));
+    opBuilder.addInput(exampleWeights.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesMakeQuantileSummaries(opBuilder.build());
   }
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 ed276f08b20..9832134f856 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
@@ -51,10 +51,10 @@ public final class BoostedTreesMakeStatsSummary extends RawOp implements Operand
   @Endpoint(describeByClass = true)
   public static BoostedTreesMakeStatsSummary create(Scope scope, Operand<TInt32> nodeIds, Operand<TFloat32> gradients, Operand<TFloat32> hessians, Iterable<Operand<TInt32>> bucketizedFeaturesList, Long maxSplits, Long numBuckets) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesMakeStatsSummary", scope.makeOpName("BoostedTreesMakeStatsSummary"));
-    opBuilder.addInput(nodeIds.asOutput());
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(hessians.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(bucketizedFeaturesList));
+    opBuilder.addInput(nodeIds.asOutput(scope));
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(hessians.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, bucketizedFeaturesList));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("max_splits", maxSplits);
     opBuilder.setAttr("num_buckets", numBuckets);
@@ -69,7 +69,7 @@ public Output<TFloat32> statsSummary() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return statsSummary;
   }
   
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 fc12d1cc2ed..10d7f4d1816 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
@@ -51,8 +51,8 @@ public final class BoostedTreesPredict extends RawOp implements Operand<TFloat32
   @Endpoint(describeByClass = true)
   public static BoostedTreesPredict create(Scope scope, Operand<?> treeEnsembleHandle, Iterable<Operand<TInt32>> bucketizedFeatures, Long logitsDimension) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesPredict", scope.makeOpName("BoostedTreesPredict"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(bucketizedFeatures));
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, bucketizedFeatures));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("logits_dimension", logitsDimension);
     return new BoostedTreesPredict(opBuilder.build());
@@ -66,7 +66,7 @@ public Output<TFloat32> logits() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return logits;
   }
   
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 08bda03ea19..7b2dd36851b 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
@@ -47,8 +47,8 @@ public final class BoostedTreesQuantileStreamResourceAddSummaries extends RawOp
   @Endpoint(describeByClass = true)
   public static BoostedTreesQuantileStreamResourceAddSummaries create(Scope scope, Operand<?> quantileStreamResourceHandle, Iterable<Operand<TFloat32>> summaries) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesQuantileStreamResourceAddSummaries", scope.makeOpName("BoostedTreesQuantileStreamResourceAddSummaries"));
-    opBuilder.addInput(quantileStreamResourceHandle.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(summaries));
+    opBuilder.addInput(quantileStreamResourceHandle.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, summaries));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesQuantileStreamResourceAddSummaries(opBuilder.build());
   }
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 58850d3e981..88f48b977d6 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
@@ -45,8 +45,8 @@ public final class BoostedTreesQuantileStreamResourceDeserialize extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesQuantileStreamResourceDeserialize create(Scope scope, Operand<?> quantileStreamResourceHandle, Iterable<Operand<TFloat32>> bucketBoundaries) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesQuantileStreamResourceDeserialize", scope.makeOpName("BoostedTreesQuantileStreamResourceDeserialize"));
-    opBuilder.addInput(quantileStreamResourceHandle.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(bucketBoundaries));
+    opBuilder.addInput(quantileStreamResourceHandle.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, bucketBoundaries));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesQuantileStreamResourceDeserialize(opBuilder.build());
   }
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 4f3c4f561b8..12215d59d24 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
@@ -69,8 +69,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BoostedTreesQuantileStreamResourceFlush create(Scope scope, Operand<?> quantileStreamResourceHandle, Operand<TInt64> numBuckets, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesQuantileStreamResourceFlush", scope.makeOpName("BoostedTreesQuantileStreamResourceFlush"));
-    opBuilder.addInput(quantileStreamResourceHandle.asOutput());
-    opBuilder.addInput(numBuckets.asOutput());
+    opBuilder.addInput(quantileStreamResourceHandle.asOutput(scope));
+    opBuilder.addInput(numBuckets.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 711e3f6acd6..0d7809780ba 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
@@ -49,7 +49,7 @@ public final class BoostedTreesQuantileStreamResourceGetBucketBoundaries extends
   @Endpoint(describeByClass = true)
   public static BoostedTreesQuantileStreamResourceGetBucketBoundaries create(Scope scope, Operand<?> quantileStreamResourceHandle, Long numFeatures) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesQuantileStreamResourceGetBucketBoundaries", scope.makeOpName("BoostedTreesQuantileStreamResourceGetBucketBoundaries"));
-    opBuilder.addInput(quantileStreamResourceHandle.asOutput());
+    opBuilder.addInput(quantileStreamResourceHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_features", numFeatures);
     return new BoostedTreesQuantileStreamResourceGetBucketBoundaries(opBuilder.build());
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 c61b77ebe38..9cc824da035 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates a handle to a BoostedTreesQuantileStreamResource.
  */
-public final class BoostedTreesQuantileStreamResourceHandleOp extends RawOp implements Operand<Tensor> {
+public final class BoostedTreesQuantileStreamResourceHandleOp extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.estimator.BoostedTreesQuantileStreamResourceHandleOp}
@@ -106,8 +106,8 @@ public Output<?> resource() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) resource;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) resource;
   }
   
   private Output<?> resource;
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 8bf4df8541e..e28340862cf 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
@@ -43,7 +43,7 @@ public final class BoostedTreesSerializeEnsemble extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesSerializeEnsemble create(Scope scope, Operand<?> treeEnsembleHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesSerializeEnsemble", scope.makeOpName("BoostedTreesSerializeEnsemble"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BoostedTreesSerializeEnsemble(opBuilder.build());
   }
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 23ef1f4f01e..192be34efdd 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
@@ -58,12 +58,12 @@ public final class BoostedTreesSparseAggregateStats extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesSparseAggregateStats create(Scope scope, Operand<TInt32> nodeIds, Operand<TFloat32> gradients, Operand<TFloat32> hessians, Operand<TInt32> featureIndices, Operand<TInt32> featureValues, Operand<TInt32> featureShape, Long maxSplits, Long numBuckets) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesSparseAggregateStats", scope.makeOpName("BoostedTreesSparseAggregateStats"));
-    opBuilder.addInput(nodeIds.asOutput());
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(hessians.asOutput());
-    opBuilder.addInput(featureIndices.asOutput());
-    opBuilder.addInput(featureValues.asOutput());
-    opBuilder.addInput(featureShape.asOutput());
+    opBuilder.addInput(nodeIds.asOutput(scope));
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(hessians.asOutput(scope));
+    opBuilder.addInput(featureIndices.asOutput(scope));
+    opBuilder.addInput(featureValues.asOutput(scope));
+    opBuilder.addInput(featureShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("max_splits", maxSplits);
     opBuilder.setAttr("num_buckets", numBuckets);
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 48afc375b67..e7e2c5ef83e 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
@@ -81,14 +81,14 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BoostedTreesSparseCalculateBestFeatureSplit create(Scope scope, Operand<TInt32> nodeIdRange, Operand<TInt32> statsSummaryIndices, Operand<TFloat32> statsSummaryValues, Operand<TInt32> statsSummaryShape, Operand<TFloat32> l1, Operand<TFloat32> l2, Operand<TFloat32> treeComplexity, Operand<TFloat32> minNodeWeight, Long logitsDimension, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesSparseCalculateBestFeatureSplit", scope.makeOpName("BoostedTreesSparseCalculateBestFeatureSplit"));
-    opBuilder.addInput(nodeIdRange.asOutput());
-    opBuilder.addInput(statsSummaryIndices.asOutput());
-    opBuilder.addInput(statsSummaryValues.asOutput());
-    opBuilder.addInput(statsSummaryShape.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(treeComplexity.asOutput());
-    opBuilder.addInput(minNodeWeight.asOutput());
+    opBuilder.addInput(nodeIdRange.asOutput(scope));
+    opBuilder.addInput(statsSummaryIndices.asOutput(scope));
+    opBuilder.addInput(statsSummaryValues.asOutput(scope));
+    opBuilder.addInput(statsSummaryShape.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(treeComplexity.asOutput(scope));
+    opBuilder.addInput(minNodeWeight.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("logits_dimension", logitsDimension);
     if (options != null) {
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 2dd38c35c59..a3897fb4171 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
@@ -56,10 +56,10 @@ public final class BoostedTreesTrainingPredict extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesTrainingPredict create(Scope scope, Operand<?> treeEnsembleHandle, Operand<TInt32> cachedTreeIds, Operand<TInt32> cachedNodeIds, Iterable<Operand<TInt32>> bucketizedFeatures, Long logitsDimension) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesTrainingPredict", scope.makeOpName("BoostedTreesTrainingPredict"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInput(cachedTreeIds.asOutput());
-    opBuilder.addInput(cachedNodeIds.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(bucketizedFeatures));
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInput(cachedTreeIds.asOutput(scope));
+    opBuilder.addInput(cachedNodeIds.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, bucketizedFeatures));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("logits_dimension", logitsDimension);
     return new BoostedTreesTrainingPredict(opBuilder.build());
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 05f2d9c1357..68ce111adff 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
@@ -62,15 +62,15 @@ public final class BoostedTreesUpdateEnsemble extends RawOp {
   @Endpoint(describeByClass = true)
   public static BoostedTreesUpdateEnsemble create(Scope scope, Operand<?> treeEnsembleHandle, Operand<TInt32> featureIds, Iterable<Operand<TInt32>> nodeIds, Iterable<Operand<TFloat32>> gains, Iterable<Operand<TInt32>> thresholds, Iterable<Operand<TFloat32>> leftNodeContribs, Iterable<Operand<TFloat32>> rightNodeContribs, Operand<TInt32> maxDepth, Operand<TFloat32> learningRate, Long pruningMode) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesUpdateEnsemble", scope.makeOpName("BoostedTreesUpdateEnsemble"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInput(featureIds.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(nodeIds));
-    opBuilder.addInputList(Operands.asOutputs(gains));
-    opBuilder.addInputList(Operands.asOutputs(thresholds));
-    opBuilder.addInputList(Operands.asOutputs(leftNodeContribs));
-    opBuilder.addInputList(Operands.asOutputs(rightNodeContribs));
-    opBuilder.addInput(maxDepth.asOutput());
-    opBuilder.addInput(learningRate.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInput(featureIds.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, nodeIds));
+    opBuilder.addInputList(Operands.asOutputs(scope, gains));
+    opBuilder.addInputList(Operands.asOutputs(scope, thresholds));
+    opBuilder.addInputList(Operands.asOutputs(scope, leftNodeContribs));
+    opBuilder.addInputList(Operands.asOutputs(scope, rightNodeContribs));
+    opBuilder.addInput(maxDepth.asOutput(scope));
+    opBuilder.addInput(learningRate.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("pruning_mode", pruningMode);
     return new BoostedTreesUpdateEnsemble(opBuilder.build());
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 0e7c81ed3a1..4e8aa0b698f 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
@@ -85,18 +85,18 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static BoostedTreesUpdateEnsembleV2 create(Scope scope, Operand<?> treeEnsembleHandle, Iterable<Operand<TInt32>> featureIds, Iterable<Operand<TInt32>> dimensionIds, Iterable<Operand<TInt32>> nodeIds, Iterable<Operand<TFloat32>> gains, Iterable<Operand<TInt32>> thresholds, Iterable<Operand<TFloat32>> leftNodeContribs, Iterable<Operand<TFloat32>> rightNodeContribs, Iterable<Operand<TString>> splitTypes, Operand<TInt32> maxDepth, Operand<TFloat32> learningRate, Operand<TInt32> pruningMode, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BoostedTreesUpdateEnsembleV2", scope.makeOpName("BoostedTreesUpdateEnsembleV2"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(featureIds));
-    opBuilder.addInputList(Operands.asOutputs(dimensionIds));
-    opBuilder.addInputList(Operands.asOutputs(nodeIds));
-    opBuilder.addInputList(Operands.asOutputs(gains));
-    opBuilder.addInputList(Operands.asOutputs(thresholds));
-    opBuilder.addInputList(Operands.asOutputs(leftNodeContribs));
-    opBuilder.addInputList(Operands.asOutputs(rightNodeContribs));
-    opBuilder.addInputList(Operands.asOutputs(splitTypes));
-    opBuilder.addInput(maxDepth.asOutput());
-    opBuilder.addInput(learningRate.asOutput());
-    opBuilder.addInput(pruningMode.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, featureIds));
+    opBuilder.addInputList(Operands.asOutputs(scope, dimensionIds));
+    opBuilder.addInputList(Operands.asOutputs(scope, nodeIds));
+    opBuilder.addInputList(Operands.asOutputs(scope, gains));
+    opBuilder.addInputList(Operands.asOutputs(scope, thresholds));
+    opBuilder.addInputList(Operands.asOutputs(scope, leftNodeContribs));
+    opBuilder.addInputList(Operands.asOutputs(scope, rightNodeContribs));
+    opBuilder.addInputList(Operands.asOutputs(scope, splitTypes));
+    opBuilder.addInput(maxDepth.asOutput(scope));
+    opBuilder.addInput(learningRate.asOutput(scope));
+    opBuilder.addInput(pruningMode.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 f7f78393822..1c8ff4e977a 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
@@ -42,7 +42,7 @@ public final class IsBoostedTreesEnsembleInitialized extends RawOp implements Op
   @Endpoint(describeByClass = true)
   public static IsBoostedTreesEnsembleInitialized create(Scope scope, Operand<?> treeEnsembleHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsBoostedTreesEnsembleInitialized", scope.makeOpName("IsBoostedTreesEnsembleInitialized"));
-    opBuilder.addInput(treeEnsembleHandle.asOutput());
+    opBuilder.addInput(treeEnsembleHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IsBoostedTreesEnsembleInitialized(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TBool> isInitialized() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return isInitialized;
   }
   
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 6561f2d1eea..f00c788ded3 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
@@ -44,7 +44,7 @@ public final class IsBoostedTreesQuantileStreamResourceInitialized extends RawOp
   @Endpoint(describeByClass = true)
   public static IsBoostedTreesQuantileStreamResourceInitialized create(Scope scope, Operand<?> quantileStreamResourceHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsBoostedTreesQuantileStreamResourceInitialized", scope.makeOpName("IsBoostedTreesQuantileStreamResourceInitialized"));
-    opBuilder.addInput(quantileStreamResourceHandle.asOutput());
+    opBuilder.addInput(quantileStreamResourceHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IsBoostedTreesQuantileStreamResourceInitialized(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<TBool> isInitialized() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return isInitialized;
   }
   
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 67e8deb8fef..a55f142c9bc 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -45,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustContrast<T extends Tensor & TNumber> extends RawOp 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.
@@ -56,10 +55,10 @@ public final class AdjustContrast<T extends Tensor & TNumber> extends RawOp impl
    * @return a new instance of AdjustContrast
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AdjustContrast<T> create(Scope scope, Operand<T> images, Operand<TFloat32> contrastFactor) {
+  public static <T extends TNumber> AdjustContrast<T> create(Scope scope, Operand<T> images, Operand<TFloat32> contrastFactor) {
     OperationBuilder opBuilder = scope.env().opBuilder("AdjustContrastv2", scope.makeOpName("AdjustContrast"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(contrastFactor.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(contrastFactor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AdjustContrast<T>(opBuilder.build());
   }
@@ -72,7 +71,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 84557ae3c57..6652f17fe35 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustHue<T extends Tensor & TNumber> extends RawOp 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.
@@ -53,10 +52,10 @@ public final class AdjustHue<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of AdjustHue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AdjustHue<T> create(Scope scope, Operand<T> images, Operand<TFloat32> delta) {
+  public static <T extends TNumber> AdjustHue<T> create(Scope scope, Operand<T> images, Operand<TFloat32> delta) {
     OperationBuilder opBuilder = scope.env().opBuilder("AdjustHue", scope.makeOpName("AdjustHue"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(delta.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(delta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AdjustHue<T>(opBuilder.build());
   }
@@ -69,7 +68,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5da9470e622..6d6627aaf88 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class AdjustSaturation<T extends Tensor & TNumber> extends RawOp 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.
@@ -53,10 +52,10 @@ public final class AdjustSaturation<T extends Tensor & TNumber> extends RawOp im
    * @return a new instance of AdjustSaturation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AdjustSaturation<T> create(Scope scope, Operand<T> images, Operand<TFloat32> scale) {
+  public static <T extends TNumber> AdjustSaturation<T> create(Scope scope, Operand<T> images, Operand<TFloat32> scale) {
     OperationBuilder opBuilder = scope.env().opBuilder("AdjustSaturation", scope.makeOpName("AdjustSaturation"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(scale.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(scale.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AdjustSaturation<T>(opBuilder.build());
   }
@@ -69,7 +68,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 1f1926163fc..0a9dded08a5 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
@@ -104,12 +104,12 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static CombinedNonMaxSuppression create(Scope scope, Operand<TFloat32> boxes, Operand<TFloat32> scores, Operand<TInt32> maxOutputSizePerClass, Operand<TInt32> maxTotalSize, Operand<TFloat32> iouThreshold, Operand<TFloat32> scoreThreshold, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CombinedNonMaxSuppression", scope.makeOpName("CombinedNonMaxSuppression"));
-    opBuilder.addInput(boxes.asOutput());
-    opBuilder.addInput(scores.asOutput());
-    opBuilder.addInput(maxOutputSizePerClass.asOutput());
-    opBuilder.addInput(maxTotalSize.asOutput());
-    opBuilder.addInput(iouThreshold.asOutput());
-    opBuilder.addInput(scoreThreshold.asOutput());
+    opBuilder.addInput(boxes.asOutput(scope));
+    opBuilder.addInput(scores.asOutput(scope));
+    opBuilder.addInput(maxOutputSizePerClass.asOutput(scope));
+    opBuilder.addInput(maxTotalSize.asOutput(scope));
+    opBuilder.addInput(iouThreshold.asOutput(scope));
+    opBuilder.addInput(scoreThreshold.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 eee22d1375b..d0baeda5658 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -108,12 +107,12 @@ private Options() {
    * @return a new instance of CropAndResize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CropAndResize create(Scope scope, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> cropSize, Options... options) {
+  public static <T extends TNumber> CropAndResize create(Scope scope, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> cropSize, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CropAndResize", scope.makeOpName("CropAndResize"));
-    opBuilder.addInput(image.asOutput());
-    opBuilder.addInput(boxes.asOutput());
-    opBuilder.addInput(boxInd.asOutput());
-    opBuilder.addInput(cropSize.asOutput());
+    opBuilder.addInput(image.asOutput(scope));
+    opBuilder.addInput(boxes.asOutput(scope));
+    opBuilder.addInput(boxInd.asOutput(scope));
+    opBuilder.addInput(cropSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -152,7 +151,7 @@ public Output<TFloat32> crops() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return crops;
   }
   
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 47eb509c9be..95b9932ff6a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -79,12 +78,12 @@ private Options() {
    * @return a new instance of CropAndResizeGradBoxes
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CropAndResizeGradBoxes create(Scope scope, Operand<TFloat32> grads, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Options... options) {
+  public static <T extends TNumber> CropAndResizeGradBoxes create(Scope scope, Operand<TFloat32> grads, Operand<T> image, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CropAndResizeGradBoxes", scope.makeOpName("CropAndResizeGradBoxes"));
-    opBuilder.addInput(grads.asOutput());
-    opBuilder.addInput(image.asOutput());
-    opBuilder.addInput(boxes.asOutput());
-    opBuilder.addInput(boxInd.asOutput());
+    opBuilder.addInput(grads.asOutput(scope));
+    opBuilder.addInput(image.asOutput(scope));
+    opBuilder.addInput(boxes.asOutput(scope));
+    opBuilder.addInput(boxInd.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -112,7 +111,7 @@ public Output<TFloat32> output() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return output;
   }
   
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 c7c953e8b96..e04f5519137 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class CropAndResizeGradImage<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class CropAndResizeGradImage<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.CropAndResizeGradImage}
@@ -84,12 +83,12 @@ private Options() {
    * @return a new instance of CropAndResizeGradImage
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CropAndResizeGradImage<T> create(Scope scope, Operand<TFloat32> grads, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> imageSize, DataType<T> T, Options... options) {
+  public static <T extends TNumber> CropAndResizeGradImage<T> create(Scope scope, Operand<TFloat32> grads, Operand<TFloat32> boxes, Operand<TInt32> boxInd, Operand<TInt32> imageSize, DataType<T> T, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CropAndResizeGradImage", scope.makeOpName("CropAndResizeGradImage"));
-    opBuilder.addInput(grads.asOutput());
-    opBuilder.addInput(boxes.asOutput());
-    opBuilder.addInput(boxInd.asOutput());
-    opBuilder.addInput(imageSize.asOutput());
+    opBuilder.addInput(grads.asOutput(scope));
+    opBuilder.addInput(boxes.asOutput(scope));
+    opBuilder.addInput(boxInd.asOutput(scope));
+    opBuilder.addInput(imageSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("T", T);
     if (options != null) {
@@ -118,7 +117,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c7191af839a..4059611ae43 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
@@ -143,8 +143,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DecodeAndCropJpeg create(Scope scope, Operand<TString> contents, Operand<TInt32> cropWindow, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeAndCropJpeg", scope.makeOpName("DecodeAndCropJpeg"));
-    opBuilder.addInput(contents.asOutput());
-    opBuilder.addInput(cropWindow.asOutput());
+    opBuilder.addInput(contents.asOutput(scope));
+    opBuilder.addInput(cropWindow.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -228,7 +228,7 @@ public Output<TUint8> image() {
   }
   
   @Override
-  public Output<TUint8> asOutput() {
+  public Output<TUint8> asOutput(Scope scope) {
     return image;
   }
   
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 23ade8ab9e9..07dbdc7855e 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
@@ -78,7 +78,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DecodeBmp create(Scope scope, Operand<TString> contents, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeBmp", scope.makeOpName("DecodeBmp"));
-    opBuilder.addInput(contents.asOutput());
+    opBuilder.addInput(contents.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -105,7 +105,7 @@ public Output<TUint8> image() {
   }
   
   @Override
-  public Output<TUint8> asOutput() {
+  public Output<TUint8> asOutput(Scope scope) {
     return image;
   }
   
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 c61b81f21c2..5f47c3482ff 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
@@ -53,7 +53,7 @@ public final class DecodeGif extends RawOp implements Operand<TUint8> {
   @Endpoint(describeByClass = true)
   public static DecodeGif create(Scope scope, Operand<TString> contents) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeGif", scope.makeOpName("DecodeGif"));
-    opBuilder.addInput(contents.asOutput());
+    opBuilder.addInput(contents.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DecodeGif(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<TUint8> image() {
   }
   
   @Override
-  public Output<TUint8> asOutput() {
+  public Output<TUint8> asOutput(Scope scope) {
     return image;
   }
   
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 4b30ea87bec..4a76c42ca80 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
@@ -141,7 +141,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DecodeJpeg create(Scope scope, Operand<TString> contents, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeJpeg", scope.makeOpName("DecodeJpeg"));
-    opBuilder.addInput(contents.asOutput());
+    opBuilder.addInput(contents.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -225,7 +225,7 @@ public Output<TUint8> image() {
   }
   
   @Override
-  public Output<TUint8> asOutput() {
+  public Output<TUint8> asOutput(Scope scope) {
     return image;
   }
   
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 3f73c54a18e..68b85cc779e 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -61,7 +60,7 @@
  * @param <T> data type for {@code image()} output
  */
 @Operator(group = "image")
-public final class DecodePng<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class DecodePng<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.DecodePng}
@@ -92,9 +91,9 @@ private Options() {
    * @return a new instance of DecodePng
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DecodePng<T> create(Scope scope, Operand<TString> contents, DataType<T> dtype, Options... options) {
+  public static <T extends TNumber> DecodePng<T> create(Scope scope, Operand<TString> contents, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodePng", scope.makeOpName("DecodePng"));
-    opBuilder.addInput(contents.asOutput());
+    opBuilder.addInput(contents.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -135,7 +134,7 @@ public Output<T> image() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return image;
   }
   
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 ca1ca14ee37..05dbe8f6e26 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -47,7 +46,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class DrawBoundingBoxes<T extends Tensor & TNumber> extends RawOp 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.
@@ -60,11 +59,11 @@ public final class DrawBoundingBoxes<T extends Tensor & TNumber> extends RawOp i
    * @return a new instance of DrawBoundingBoxes
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DrawBoundingBoxes<T> create(Scope scope, Operand<T> images, Operand<TFloat32> boxes, Operand<TFloat32> colors) {
+  public static <T extends TNumber> DrawBoundingBoxes<T> create(Scope scope, Operand<T> images, Operand<TFloat32> boxes, Operand<TFloat32> colors) {
     OperationBuilder opBuilder = scope.env().opBuilder("DrawBoundingBoxesV2", scope.makeOpName("DrawBoundingBoxes"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(boxes.asOutput());
-    opBuilder.addInput(colors.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(boxes.asOutput(scope));
+    opBuilder.addInput(colors.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DrawBoundingBoxes<T>(opBuilder.build());
   }
@@ -78,7 +77,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a08e1d0fbc8..aab7d0bfc88 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
@@ -163,7 +163,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static EncodeJpeg create(Scope scope, Operand<TUint8> image, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EncodeJpeg", scope.makeOpName("EncodeJpeg"));
-    opBuilder.addInput(image.asOutput());
+    opBuilder.addInput(image.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -271,7 +271,7 @@ public Output<TString> contents() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return contents;
   }
   
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 8c9fe1afd49..295630758d7 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
@@ -50,8 +50,8 @@ public final class EncodeJpegVariableQuality extends RawOp implements Operand<TS
   @Endpoint(describeByClass = true)
   public static EncodeJpegVariableQuality create(Scope scope, Operand<TUint8> images, Operand<TInt32> quality) {
     OperationBuilder opBuilder = scope.env().opBuilder("EncodeJpegVariableQuality", scope.makeOpName("EncodeJpegVariableQuality"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(quality.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(quality.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new EncodeJpegVariableQuality(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<TString> contents() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return contents;
   }
   
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 43a53aebfd4..6f10fad9ecc 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -83,9 +82,9 @@ private Options() {
    * @return a new instance of EncodePng
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> EncodePng create(Scope scope, Operand<T> image, Options... options) {
+  public static <T extends TNumber> EncodePng create(Scope scope, Operand<T> image, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EncodePng", scope.makeOpName("EncodePng"));
-    opBuilder.addInput(image.asOutput());
+    opBuilder.addInput(image.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -112,7 +111,7 @@ public Output<TString> contents() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return contents;
   }
   
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 74ac3be5a05..2f41f806d48 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
@@ -129,9 +129,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ExtractGlimpse create(Scope scope, Operand<TFloat32> input, Operand<TInt32> size, Operand<TFloat32> offsets, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExtractGlimpse", scope.makeOpName("ExtractGlimpse"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(size.asOutput());
-    opBuilder.addInput(offsets.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
+    opBuilder.addInput(offsets.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -195,7 +195,7 @@ public Output<TFloat32> glimpse() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return glimpse;
   }
   
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 fc8f8e1889a..834b298369d 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Extract `patches` from `images` and put them in the "depth" output dimension.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code patches()} output
  */
 @Operator(group = "image")
-public final class ExtractImagePatches<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ExtractImagePatches<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ExtractImagePatches operation.
@@ -54,9 +54,9 @@ public final class ExtractImagePatches<T extends Tensor> extends RawOp implement
    * @return a new instance of ExtractImagePatches
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ExtractImagePatches<T> create(Scope scope, Operand<T> images, List<Long> ksizes, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends TType> ExtractImagePatches<T> create(Scope scope, Operand<T> images, List<Long> ksizes, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExtractImagePatches", scope.makeOpName("ExtractImagePatches"));
-    opBuilder.addInput(images.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizesArray = new long[ksizes.size()];
     for (int i = 0; i < ksizesArray.length; ++i) {
@@ -88,7 +88,7 @@ public Output<T> patches() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return patches;
   }
   
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 dccb442c0b3..07b0d8b3576 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * @param <T> data type for {@code imageShape()} output
  */
 @Operator(group = "image")
-public final class ExtractJpegShape<T extends Tensor & TNumber> extends RawOp 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.
@@ -51,9 +50,9 @@ public final class ExtractJpegShape<T extends Tensor & TNumber> extends RawOp im
    * @return a new instance of ExtractJpegShape
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ExtractJpegShape<T> create(Scope scope, Operand<TString> contents, DataType<T> outputType) {
+  public static <T extends TNumber> ExtractJpegShape<T> create(Scope scope, Operand<TString> contents, DataType<T> outputType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ExtractJpegShape", scope.makeOpName("ExtractJpegShape"));
-    opBuilder.addInput(contents.asOutput());
+    opBuilder.addInput(contents.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_type", outputType);
     return new ExtractJpegShape<T>(opBuilder.build());
@@ -79,7 +78,7 @@ public Output<T> imageShape() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return imageShape;
   }
   
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 16d71155a66..40abbd7105e 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
@@ -82,13 +82,13 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static GenerateBoundingBoxProposals create(Scope scope, Operand<TFloat32> scores, Operand<TFloat32> bboxDeltas, Operand<TFloat32> imageInfo, Operand<TFloat32> anchors, Operand<TFloat32> nmsThreshold, Operand<TInt32> preNmsTopn, Operand<TFloat32> minSize, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("GenerateBoundingBoxProposals", scope.makeOpName("GenerateBoundingBoxProposals"));
-    opBuilder.addInput(scores.asOutput());
-    opBuilder.addInput(bboxDeltas.asOutput());
-    opBuilder.addInput(imageInfo.asOutput());
-    opBuilder.addInput(anchors.asOutput());
-    opBuilder.addInput(nmsThreshold.asOutput());
-    opBuilder.addInput(preNmsTopn.asOutput());
-    opBuilder.addInput(minSize.asOutput());
+    opBuilder.addInput(scores.asOutput(scope));
+    opBuilder.addInput(bboxDeltas.asOutput(scope));
+    opBuilder.addInput(imageInfo.asOutput(scope));
+    opBuilder.addInput(anchors.asOutput(scope));
+    opBuilder.addInput(nmsThreshold.asOutput(scope));
+    opBuilder.addInput(preNmsTopn.asOutput(scope));
+    opBuilder.addInput(minSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 a9abfca91e1..8dc9bc854d4 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class HsvToRgb<T extends Tensor & TNumber> extends RawOp 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.
@@ -50,9 +49,9 @@ public final class HsvToRgb<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of HsvToRgb
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> HsvToRgb<T> create(Scope scope, Operand<T> images) {
+  public static <T extends TNumber> HsvToRgb<T> create(Scope scope, Operand<T> images) {
     OperationBuilder opBuilder = scope.env().opBuilder("HSVToRGB", scope.makeOpName("HsvToRgb"));
-    opBuilder.addInput(images.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new HsvToRgb<T>(opBuilder.build());
   }
@@ -65,7 +64,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java
index 660b95c5373..9c77d95fc79 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/image/ImageProjectiveTransformV2.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -41,7 +40,7 @@
  * 
  * @param <T> data type for {@code transformedImages()} output
  */
-public final class ImageProjectiveTransformV2<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ImageProjectiveTransformV2<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ImageProjectiveTransformV2}
@@ -76,11 +75,11 @@ private Options() {
    * @return a new instance of ImageProjectiveTransformV2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ImageProjectiveTransformV2<T> create(Scope scope, Operand<T> images, Operand<TFloat32> transforms, Operand<TInt32> outputShape, String interpolation, Options... options) {
+  public static <T extends TNumber> ImageProjectiveTransformV2<T> create(Scope scope, Operand<T> images, Operand<TFloat32> transforms, Operand<TInt32> outputShape, String interpolation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ImageProjectiveTransformV2", scope.makeOpName("ImageProjectiveTransformV2"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(transforms.asOutput());
-    opBuilder.addInput(outputShape.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(transforms.asOutput(scope));
+    opBuilder.addInput(outputShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("interpolation", interpolation);
     if (options != null) {
@@ -109,7 +108,7 @@ public Output<T> transformedImages() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return transformedImages;
   }
   
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 55eab58c7fc..773cce664c9 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
@@ -50,9 +50,9 @@ public final class NearestNeighbors extends RawOp {
   @Endpoint(describeByClass = true)
   public static NearestNeighbors create(Scope scope, Operand<TFloat32> points, Operand<TFloat32> centers, Operand<TInt64> k) {
     OperationBuilder opBuilder = scope.env().opBuilder("NearestNeighbors", scope.makeOpName("NearestNeighbors"));
-    opBuilder.addInput(points.asOutput());
-    opBuilder.addInput(centers.asOutput());
-    opBuilder.addInput(k.asOutput());
+    opBuilder.addInput(points.asOutput(scope));
+    opBuilder.addInput(centers.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new NearestNeighbors(opBuilder.build());
   }
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 57460359430..03e460a39e1 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -58,7 +57,7 @@
  * @param <T> data type for {@code selectedScores()} output
  */
 @Operator(group = "image")
-public final class NonMaxSuppression<T extends Tensor & TNumber> extends RawOp {
+public final class NonMaxSuppression<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.NonMaxSuppression}
@@ -100,14 +99,14 @@ private Options() {
    * @return a new instance of NonMaxSuppression
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> NonMaxSuppression<T> create(Scope scope, Operand<T> boxes, Operand<T> scores, Operand<TInt32> maxOutputSize, Operand<T> iouThreshold, Operand<T> scoreThreshold, Operand<T> softNmsSigma, Options... options) {
+  public static <T extends TNumber> NonMaxSuppression<T> create(Scope scope, Operand<T> boxes, Operand<T> scores, Operand<TInt32> maxOutputSize, Operand<T> iouThreshold, Operand<T> scoreThreshold, Operand<T> softNmsSigma, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("NonMaxSuppressionV5", scope.makeOpName("NonMaxSuppression"));
-    opBuilder.addInput(boxes.asOutput());
-    opBuilder.addInput(scores.asOutput());
-    opBuilder.addInput(maxOutputSize.asOutput());
-    opBuilder.addInput(iouThreshold.asOutput());
-    opBuilder.addInput(scoreThreshold.asOutput());
-    opBuilder.addInput(softNmsSigma.asOutput());
+    opBuilder.addInput(boxes.asOutput(scope));
+    opBuilder.addInput(scores.asOutput(scope));
+    opBuilder.addInput(maxOutputSize.asOutput(scope));
+    opBuilder.addInput(iouThreshold.asOutput(scope));
+    opBuilder.addInput(scoreThreshold.asOutput(scope));
+    opBuilder.addInput(softNmsSigma.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 97e14206922..ee5566cab42 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
@@ -68,11 +68,11 @@ public final class NonMaxSuppressionWithOverlaps extends RawOp implements Operan
   @Endpoint(describeByClass = true)
   public static NonMaxSuppressionWithOverlaps create(Scope scope, Operand<TFloat32> overlaps, Operand<TFloat32> scores, Operand<TInt32> maxOutputSize, Operand<TFloat32> overlapThreshold, Operand<TFloat32> scoreThreshold) {
     OperationBuilder opBuilder = scope.env().opBuilder("NonMaxSuppressionWithOverlaps", scope.makeOpName("NonMaxSuppressionWithOverlaps"));
-    opBuilder.addInput(overlaps.asOutput());
-    opBuilder.addInput(scores.asOutput());
-    opBuilder.addInput(maxOutputSize.asOutput());
-    opBuilder.addInput(overlapThreshold.asOutput());
-    opBuilder.addInput(scoreThreshold.asOutput());
+    opBuilder.addInput(overlaps.asOutput(scope));
+    opBuilder.addInput(scores.asOutput(scope));
+    opBuilder.addInput(maxOutputSize.asOutput(scope));
+    opBuilder.addInput(overlapThreshold.asOutput(scope));
+    opBuilder.addInput(scoreThreshold.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new NonMaxSuppressionWithOverlaps(opBuilder.build());
   }
@@ -86,7 +86,7 @@ public Output<TInt32> selectedIndices() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return selectedIndices;
   }
   
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 cb2c7aaa8ab..3fb44255918 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Resize quantized `images` to `size` using quantized bilinear interpolation.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code resizedImages()} output
  */
 @Operator(group = "image")
-public final class QuantizedResizeBilinear<T extends Tensor> extends RawOp {
+public final class QuantizedResizeBilinear<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.QuantizedResizeBilinear}
@@ -81,12 +81,12 @@ private Options() {
    * @return a new instance of QuantizedResizeBilinear
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> QuantizedResizeBilinear<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
+  public static <T extends TType> QuantizedResizeBilinear<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedResizeBilinear", scope.makeOpName("QuantizedResizeBilinear"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(size.asOutput());
-    opBuilder.addInput(min.asOutput());
-    opBuilder.addInput(max.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
+    opBuilder.addInput(min.asOutput(scope));
+    opBuilder.addInput(max.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 e1c0a48cd81..ed52374d83d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class RandomCrop<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class RandomCrop<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.RandomCrop}
@@ -84,10 +83,10 @@ private Options() {
    * @return a new instance of RandomCrop
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> RandomCrop<T> create(Scope scope, Operand<T> image, Operand<TInt64> size, Options... options) {
+  public static <T extends TNumber> RandomCrop<T> create(Scope scope, Operand<T> image, Operand<TInt64> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomCrop", scope.makeOpName("RandomCrop"));
-    opBuilder.addInput(image.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(image.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -126,7 +125,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 25830bd2b28..3d35691026d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -79,10 +78,10 @@ private Options() {
    * @return a new instance of ResizeArea
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResizeArea create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends TNumber> ResizeArea create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeArea", scope.makeOpName("ResizeArea"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -111,7 +110,7 @@ public Output<TFloat32> resizedImages() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return resizedImages;
   }
   
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 013b594fe44..f59af072e1b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -78,10 +77,10 @@ private Options() {
    * @return a new instance of ResizeBicubic
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResizeBicubic create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends TNumber> ResizeBicubic create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBicubic", scope.makeOpName("ResizeBicubic"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -120,7 +119,7 @@ public Output<TFloat32> resizedImages() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return resizedImages;
   }
   
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 666da6e857f..3494bb6f46d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeBicubicGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ResizeBicubicGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBicubicGrad}
@@ -76,10 +75,10 @@ private Options() {
    * @return a new instance of ResizeBicubicGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResizeBicubicGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
+  public static <T extends TNumber> ResizeBicubicGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBicubicGrad", scope.makeOpName("ResizeBicubicGrad"));
-    opBuilder.addInput(grads.asOutput());
-    opBuilder.addInput(originalImage.asOutput());
+    opBuilder.addInput(grads.asOutput(scope));
+    opBuilder.addInput(originalImage.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -119,7 +118,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 3be74c76b08..dfa4674d755 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -78,10 +77,10 @@ private Options() {
    * @return a new instance of ResizeBilinear
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResizeBilinear create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends TNumber> ResizeBilinear create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBilinear", scope.makeOpName("ResizeBilinear"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -120,7 +119,7 @@ public Output<TFloat32> resizedImages() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return resizedImages;
   }
   
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 f954077c213..47ae9c32df9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeBilinearGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ResizeBilinearGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeBilinearGrad}
@@ -76,10 +75,10 @@ private Options() {
    * @return a new instance of ResizeBilinearGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResizeBilinearGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
+  public static <T extends TNumber> ResizeBilinearGrad<T> create(Scope scope, Operand<TFloat32> grads, Operand<T> originalImage, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeBilinearGrad", scope.makeOpName("ResizeBilinearGrad"));
-    opBuilder.addInput(grads.asOutput());
-    opBuilder.addInput(originalImage.asOutput());
+    opBuilder.addInput(grads.asOutput(scope));
+    opBuilder.addInput(originalImage.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -119,7 +118,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c7cf19e3d63..9ed636036e0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code resizedImages()} output
  */
 @Operator(group = "image")
-public final class ResizeNearestNeighbor<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ResizeNearestNeighbor<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeNearestNeighbor}
@@ -77,10 +76,10 @@ private Options() {
    * @return a new instance of ResizeNearestNeighbor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResizeNearestNeighbor<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
+  public static <T extends TNumber> ResizeNearestNeighbor<T> create(Scope scope, Operand<T> images, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeNearestNeighbor", scope.makeOpName("ResizeNearestNeighbor"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -119,7 +118,7 @@ public Output<T> resizedImages() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return resizedImages;
   }
   
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 72d13a2ab86..fedb0391be3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class ResizeNearestNeighborGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ResizeNearestNeighborGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ResizeNearestNeighborGrad}
@@ -76,10 +75,10 @@ private Options() {
    * @return a new instance of ResizeNearestNeighborGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ResizeNearestNeighborGrad<T> create(Scope scope, Operand<T> grads, Operand<TInt32> size, Options... options) {
+  public static <T extends TNumber> ResizeNearestNeighborGrad<T> create(Scope scope, Operand<T> grads, Operand<TInt32> size, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResizeNearestNeighborGrad", scope.makeOpName("ResizeNearestNeighborGrad"));
-    opBuilder.addInput(grads.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(grads.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -118,7 +117,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a382ffcac4e..4c053a6c673 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,7 +53,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "image")
-public final class RgbToHsv<T extends Tensor & TNumber> extends RawOp 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.
@@ -64,9 +63,9 @@ public final class RgbToHsv<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of RgbToHsv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> RgbToHsv<T> create(Scope scope, Operand<T> images) {
+  public static <T extends TNumber> RgbToHsv<T> create(Scope scope, Operand<T> images) {
     OperationBuilder opBuilder = scope.env().opBuilder("RGBToHSV", scope.makeOpName("RgbToHsv"));
-    opBuilder.addInput(images.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RgbToHsv<T>(opBuilder.build());
   }
@@ -79,7 +78,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 1296d783d92..f7df9dfa5c0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -73,7 +72,7 @@
  * @param <T> data type for {@code begin()} output
  */
 @Operator(group = "image")
-public final class SampleDistortedBoundingBox<T extends Tensor & TNumber> extends RawOp {
+public final class SampleDistortedBoundingBox<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.SampleDistortedBoundingBox}
@@ -162,11 +161,11 @@ private Options() {
    * @return a new instance of SampleDistortedBoundingBox
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SampleDistortedBoundingBox<T> create(Scope scope, Operand<T> imageSize, Operand<TFloat32> boundingBoxes, Operand<TFloat32> minObjectCovered, Options... options) {
+  public static <T extends TNumber> SampleDistortedBoundingBox<T> create(Scope scope, Operand<T> imageSize, Operand<TFloat32> boundingBoxes, Operand<TFloat32> minObjectCovered, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SampleDistortedBoundingBoxV2", scope.makeOpName("SampleDistortedBoundingBox"));
-    opBuilder.addInput(imageSize.asOutput());
-    opBuilder.addInput(boundingBoxes.asOutput());
-    opBuilder.addInput(minObjectCovered.asOutput());
+    opBuilder.addInput(imageSize.asOutput(scope));
+    opBuilder.addInput(boundingBoxes.asOutput(scope));
+    opBuilder.addInput(minObjectCovered.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 78b665ebfd6..4f0d8c54b11 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -75,12 +74,12 @@ private Options() {
    * @return a new instance of ScaleAndTranslate
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ScaleAndTranslate create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
+  public static <T extends TNumber> ScaleAndTranslate create(Scope scope, Operand<T> images, Operand<TInt32> size, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScaleAndTranslate", scope.makeOpName("ScaleAndTranslate"));
-    opBuilder.addInput(images.asOutput());
-    opBuilder.addInput(size.asOutput());
-    opBuilder.addInput(scale.asOutput());
-    opBuilder.addInput(translation.asOutput());
+    opBuilder.addInput(images.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
+    opBuilder.addInput(scale.asOutput(scope));
+    opBuilder.addInput(translation.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -116,7 +115,7 @@ public Output<TFloat32> resizedImages() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return resizedImages;
   }
   
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 eba5be1cd67..500875995a1 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
 /**
  * @param <T> data type for {@code output()} output
  */
-public final class ScaleAndTranslateGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class ScaleAndTranslateGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.image.ScaleAndTranslateGrad}
@@ -74,12 +73,12 @@ private Options() {
    * @return a new instance of ScaleAndTranslateGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ScaleAndTranslateGrad<T> create(Scope scope, Operand<T> grads, Operand<T> originalImage, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
+  public static <T extends TNumber> ScaleAndTranslateGrad<T> create(Scope scope, Operand<T> grads, Operand<T> originalImage, Operand<TFloat32> scale, Operand<TFloat32> translation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScaleAndTranslateGrad", scope.makeOpName("ScaleAndTranslateGrad"));
-    opBuilder.addInput(grads.asOutput());
-    opBuilder.addInput(originalImage.asOutput());
-    opBuilder.addInput(scale.asOutput());
-    opBuilder.addInput(translation.asOutput());
+    opBuilder.addInput(grads.asOutput(scope));
+    opBuilder.addInput(originalImage.asOutput(scope));
+    opBuilder.addInput(scale.asOutput(scope));
+    opBuilder.addInput(translation.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -115,7 +114,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 7abe6aaa1f1..534d54393fd 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
@@ -46,7 +46,7 @@ public final class DecodeBase64 extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static DecodeBase64 create(Scope scope, Operand<TString> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeBase64", scope.makeOpName("DecodeBase64"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DecodeBase64(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 01a55de64ca..ee471060f38 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
@@ -71,7 +71,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DecodeCompressed create(Scope scope, Operand<TString> bytes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeCompressed", scope.makeOpName("DecodeCompressed"));
-    opBuilder.addInput(bytes.asOutput());
+    opBuilder.addInput(bytes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +100,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 a5dcc779c6e..4ef472cbb33 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
@@ -24,13 +24,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Convert CSV records to tensors. Each column maps to one tensor.
@@ -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 RawOp implements Iterable<Operand<Tensor>> {
+public final class DecodeCsv extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodeCsv}
@@ -105,8 +105,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static DecodeCsv create(Scope scope, Operand<TString> records, Iterable<Operand<?>> recordDefaults, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeCSV", scope.makeOpName("DecodeCsv"));
-    opBuilder.addInput(records.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(recordDefaults));
+    opBuilder.addInput(records.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, recordDefaults));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -170,7 +170,7 @@ public List<Output<?>> output() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) output.iterator();
   }
   
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 0f5b155c267..2264d948124 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
@@ -51,7 +51,7 @@ public final class DecodeJsonExample extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static DecodeJsonExample create(Scope scope, Operand<TString> jsonExamples) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeJSONExample", scope.makeOpName("DecodeJsonExample"));
-    opBuilder.addInput(jsonExamples.asOutput());
+    opBuilder.addInput(jsonExamples.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DecodeJsonExample(opBuilder.build());
   }
@@ -65,7 +65,7 @@ public Output<TString> binaryExamples() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return binaryExamples;
   }
   
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 996b2b66067..00ddce41d9d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class DecodePaddedRaw<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class DecodePaddedRaw<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodePaddedRaw}
@@ -71,10 +70,10 @@ private Options() {
    * @return a new instance of DecodePaddedRaw
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DecodePaddedRaw<T> create(Scope scope, Operand<TString> inputBytes, Operand<TInt32> fixedLength, DataType<T> outType, Options... options) {
+  public static <T extends TNumber> DecodePaddedRaw<T> create(Scope scope, Operand<TString> inputBytes, Operand<TInt32> fixedLength, DataType<T> outType, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodePaddedRaw", scope.makeOpName("DecodePaddedRaw"));
-    opBuilder.addInput(inputBytes.asOutput());
-    opBuilder.addInput(fixedLength.asOutput());
+    opBuilder.addInput(inputBytes.asOutput(scope));
+    opBuilder.addInput(fixedLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     if (options != null) {
@@ -105,7 +104,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 8ea48640001..6af22467a5a 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reinterpret the bytes of a string as a vector of numbers.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class DecodeRaw<T extends Tensor> extends RawOp implements Operand<T> {
+public final class DecodeRaw<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.DecodeRaw}
@@ -68,9 +68,9 @@ private Options() {
    * @return a new instance of DecodeRaw
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DecodeRaw<T> create(Scope scope, Operand<TString> bytes, DataType<T> outType, Options... options) {
+  public static <T extends TType> DecodeRaw<T> create(Scope scope, Operand<TString> bytes, DataType<T> outType, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DecodeRaw", scope.makeOpName("DecodeRaw"));
-    opBuilder.addInput(bytes.asOutput());
+    opBuilder.addInput(bytes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     if (options != null) {
@@ -102,7 +102,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 75138c95b6c..cf2fab02a90 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Deserialize and concatenate `SparseTensors` from a serialized minibatch.
@@ -78,7 +78,7 @@
  * @param <T> data type for {@code sparseValues()} output
  */
 @Operator(group = "io")
-public final class DeserializeManySparse<T extends Tensor> extends RawOp {
+public final class DeserializeManySparse<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeserializeManySparse operation.
@@ -90,9 +90,9 @@ public final class DeserializeManySparse<T extends Tensor> extends RawOp {
    * @return a new instance of DeserializeManySparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DeserializeManySparse<T> create(Scope scope, Operand<TString> serializedSparse, DataType<T> dtype) {
+  public static <T extends TType> DeserializeManySparse<T> create(Scope scope, Operand<TString> serializedSparse, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeserializeManySparse", scope.makeOpName("DeserializeManySparse"));
-    opBuilder.addInput(serializedSparse.asOutput());
+    opBuilder.addInput(serializedSparse.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new DeserializeManySparse<T>(opBuilder.build());
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 9dbfbb079b2..958977db5da 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
@@ -70,7 +70,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static EncodeBase64 create(Scope scope, Operand<TString> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EncodeBase64", scope.makeOpName("EncodeBase64"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -97,7 +97,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 d9c95edfe7e..90f052bd212 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A queue that produces elements in first-in first-out order.
  */
 @Operator(group = "io")
-public final class FifoQueue extends RawOp implements Operand<Tensor> {
+public final class FifoQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.FifoQueue}
@@ -171,8 +171,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 6de633b08bf..609b6cbc9f5 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs fixed-length records from a file.
  */
 @Operator(group = "io")
-public final class FixedLengthRecordReader extends RawOp implements Operand<Tensor> {
+public final class FixedLengthRecordReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.FixedLengthRecordReader}
@@ -194,8 +194,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) readerHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 dd0b8f15173..e402d71fe36 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the queued work as both the key and value.
@@ -34,7 +34,7 @@
  * work string and output (work, work).
  */
 @Operator(group = "io")
-public final class IdentityReader extends RawOp implements Operand<Tensor> {
+public final class IdentityReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.IdentityReader}
@@ -115,8 +115,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) readerHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 aa8c476a0c1..26c647c1e6a 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
@@ -111,7 +111,7 @@ public Output<TString> readerHandle() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return readerHandle;
   }
   
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 5c9d5bcd681..5bf722771a1 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
@@ -47,7 +47,7 @@ public final class MatchingFiles extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static MatchingFiles create(Scope scope, Operand<TString> pattern) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatchingFiles", scope.makeOpName("MatchingFiles"));
-    opBuilder.addInput(pattern.asOutput());
+    opBuilder.addInput(pattern.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MatchingFiles(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<TString> filenames() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return filenames;
   }
   
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 2fe56f42f27..22c2fac5b0f 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A queue that produces elements in first-in first-out order.
@@ -38,7 +38,7 @@
  * size of any given element in the minibatch.  See below for details.
  */
 @Operator(group = "io")
-public final class PaddingFifoQueue extends RawOp implements Operand<Tensor> {
+public final class PaddingFifoQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.PaddingFifoQueue}
@@ -183,8 +183,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 1c0b73c5cca..7c1ecc98fbb 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
@@ -32,7 +32,6 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TNumber;
 
 /**
  * Transforms a vector of tf.Example protos (as strings) into typed tensors.
@@ -99,12 +98,12 @@ public final class ParseExample extends RawOp {
   @Endpoint(describeByClass = true)
   public static ParseExample create(Scope scope, Operand<TString> serialized, Operand<TString> names, Operand<TString> sparseKeys, Operand<TString> denseKeys, Operand<TString> raggedKeys, Iterable<Operand<?>> denseDefaults, Long numSparse, List<DataType<?>> sparseTypes, List<DataType<?>> raggedValueTypes, List<DataType<?>> raggedSplitTypes, List<Shape> denseShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParseExampleV2", scope.makeOpName("ParseExample"));
-    opBuilder.addInput(serialized.asOutput());
-    opBuilder.addInput(names.asOutput());
-    opBuilder.addInput(sparseKeys.asOutput());
-    opBuilder.addInput(denseKeys.asOutput());
-    opBuilder.addInput(raggedKeys.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(denseDefaults));
+    opBuilder.addInput(serialized.asOutput(scope));
+    opBuilder.addInput(names.asOutput(scope));
+    opBuilder.addInput(sparseKeys.asOutput(scope));
+    opBuilder.addInput(denseKeys.asOutput(scope));
+    opBuilder.addInput(raggedKeys.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, denseDefaults));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_sparse", numSparse);
     DataType[] sparseTypesArray = new DataType[sparseTypes.size()];
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 d7d83defcca..b5e3cc250c0 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
@@ -33,7 +33,6 @@
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
-import org.tensorflow.types.family.TNumber;
 
 /**
  * Transforms a vector of tf.io.SequenceExample protos (as strings) into
@@ -155,16 +154,16 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ParseSequenceExample create(Scope scope, Operand<TString> serialized, Operand<TString> debugName, Operand<TString> contextSparseKeys, Operand<TString> contextDenseKeys, Operand<TString> contextRaggedKeys, Operand<TString> featureListSparseKeys, Operand<TString> featureListDenseKeys, Operand<TString> featureListRaggedKeys, Operand<TBool> featureListDenseMissingAssumedEmpty, Iterable<Operand<?>> contextDenseDefaults, List<DataType<?>> contextSparseTypes, List<DataType<?>> contextRaggedValueTypes, List<DataType<?>> contextRaggedSplitTypes, List<DataType<?>> featureListDenseTypes, List<DataType<?>> featureListSparseTypes, List<DataType<?>> featureListRaggedValueTypes, List<DataType<?>> featureListRaggedSplitTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParseSequenceExampleV2", scope.makeOpName("ParseSequenceExample"));
-    opBuilder.addInput(serialized.asOutput());
-    opBuilder.addInput(debugName.asOutput());
-    opBuilder.addInput(contextSparseKeys.asOutput());
-    opBuilder.addInput(contextDenseKeys.asOutput());
-    opBuilder.addInput(contextRaggedKeys.asOutput());
-    opBuilder.addInput(featureListSparseKeys.asOutput());
-    opBuilder.addInput(featureListDenseKeys.asOutput());
-    opBuilder.addInput(featureListRaggedKeys.asOutput());
-    opBuilder.addInput(featureListDenseMissingAssumedEmpty.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(contextDenseDefaults));
+    opBuilder.addInput(serialized.asOutput(scope));
+    opBuilder.addInput(debugName.asOutput(scope));
+    opBuilder.addInput(contextSparseKeys.asOutput(scope));
+    opBuilder.addInput(contextDenseKeys.asOutput(scope));
+    opBuilder.addInput(contextRaggedKeys.asOutput(scope));
+    opBuilder.addInput(featureListSparseKeys.asOutput(scope));
+    opBuilder.addInput(featureListDenseKeys.asOutput(scope));
+    opBuilder.addInput(featureListRaggedKeys.asOutput(scope));
+    opBuilder.addInput(featureListDenseMissingAssumedEmpty.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, contextDenseDefaults));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] contextSparseTypesArray = new DataType[contextSparseTypes.size()];
     for (int i = 0; i < contextSparseTypesArray.length; ++i) {
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 95e8f11018b..573470e2b92 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
@@ -78,8 +78,8 @@ public final class ParseSingleExample extends RawOp {
   @Endpoint(describeByClass = true)
   public static ParseSingleExample create(Scope scope, Operand<TString> serialized, Iterable<Operand<?>> denseDefaults, Long numSparse, List<String> sparseKeys, List<String> denseKeys, List<DataType<?>> sparseTypes, List<Shape> denseShapes) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParseSingleExample", scope.makeOpName("ParseSingleExample"));
-    opBuilder.addInput(serialized.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(denseDefaults));
+    opBuilder.addInput(serialized.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, denseDefaults));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_sparse", numSparse);
     String[] sparseKeysArray = new String[sparseKeys.size()];
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 4457e099ea8..2f3908de175 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
@@ -124,14 +124,14 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ParseSingleSequenceExample create(Scope scope, Operand<TString> serialized, Operand<TString> featureListDenseMissingAssumedEmpty, Iterable<Operand<TString>> contextSparseKeys, Iterable<Operand<TString>> contextDenseKeys, Iterable<Operand<TString>> featureListSparseKeys, Iterable<Operand<TString>> featureListDenseKeys, Iterable<Operand<?>> contextDenseDefaults, Operand<TString> debugName, List<DataType<?>> contextSparseTypes, List<DataType<?>> featureListDenseTypes, List<DataType<?>> featureListSparseTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParseSingleSequenceExample", scope.makeOpName("ParseSingleSequenceExample"));
-    opBuilder.addInput(serialized.asOutput());
-    opBuilder.addInput(featureListDenseMissingAssumedEmpty.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(contextSparseKeys));
-    opBuilder.addInputList(Operands.asOutputs(contextDenseKeys));
-    opBuilder.addInputList(Operands.asOutputs(featureListSparseKeys));
-    opBuilder.addInputList(Operands.asOutputs(featureListDenseKeys));
-    opBuilder.addInputList(Operands.asOutputs(contextDenseDefaults));
-    opBuilder.addInput(debugName.asOutput());
+    opBuilder.addInput(serialized.asOutput(scope));
+    opBuilder.addInput(featureListDenseMissingAssumedEmpty.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, contextSparseKeys));
+    opBuilder.addInputList(Operands.asOutputs(scope, contextDenseKeys));
+    opBuilder.addInputList(Operands.asOutputs(scope, featureListSparseKeys));
+    opBuilder.addInputList(Operands.asOutputs(scope, featureListDenseKeys));
+    opBuilder.addInputList(Operands.asOutputs(scope, contextDenseDefaults));
+    opBuilder.addInput(debugName.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] contextSparseTypesArray = new DataType[contextSparseTypes.size()];
     for (int i = 0; i < contextSparseTypesArray.length; ++i) {
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 9f209cc8b24..1b1f1d7c950 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Transforms a serialized tensorflow.TensorProto proto into a Tensor.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "io")
-public final class ParseTensor<T extends Tensor> extends RawOp 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.
@@ -47,9 +47,9 @@ public final class ParseTensor<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of ParseTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ParseTensor<T> create(Scope scope, Operand<TString> serialized, DataType<T> outType) {
+  public static <T extends TType> ParseTensor<T> create(Scope scope, Operand<TString> serialized, DataType<T> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParseTensor", scope.makeOpName("ParseTensor"));
-    opBuilder.addInput(serialized.asOutput());
+    opBuilder.addInput(serialized.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new ParseTensor<T>(opBuilder.build());
@@ -63,7 +63,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 2ce7d5b0d34..2f424d7e328 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A queue that produces elements sorted by the first component value.
@@ -40,7 +40,7 @@
  * entry in their input (resp. output) lists.
  */
 @Operator(group = "io")
-public final class PriorityQueue extends RawOp implements Operand<Tensor> {
+public final class PriorityQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.PriorityQueue}
@@ -157,8 +157,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 d2bbb349ec0..da2a1b02b1d 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
@@ -68,7 +68,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static QueueClose create(Scope scope, Operand<?> handle, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueCloseV2", scope.makeOpName("QueueClose"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 2ac307329d7..6108a7cd5cb 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,11 +25,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Dequeues a tuple of one or more tensors from the given queue.
@@ -42,7 +42,7 @@
  * has been dequeued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueDequeue extends RawOp implements Iterable<Operand<Tensor>> {
+public final class QueueDequeue extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeue}
@@ -77,7 +77,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static QueueDequeue create(Scope scope, Operand<?> handle, List<DataType<?>> componentTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueDequeueV2", scope.makeOpName("QueueDequeue"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] componentTypesArray = new DataType[componentTypes.size()];
     for (int i = 0; i < componentTypesArray.length; ++i) {
@@ -112,7 +112,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 de03edb04a7..a98c216a927 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Dequeues `n` tuples of one or more tensors from the given queue.
@@ -50,7 +50,7 @@
  * have been dequeued (or 'timeout_ms' elapses, if specified).
  */
 @Operator(group = "io")
-public final class QueueDequeueMany extends RawOp implements Iterable<Operand<Tensor>> {
+public final class QueueDequeueMany extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeueMany}
@@ -86,8 +86,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static QueueDequeueMany create(Scope scope, Operand<?> handle, Operand<TInt32> n, List<DataType<?>> componentTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueDequeueManyV2", scope.makeOpName("QueueDequeueMany"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(n.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(n.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] componentTypesArray = new DataType[componentTypes.size()];
     for (int i = 0; i < componentTypesArray.length; ++i) {
@@ -122,7 +122,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 1f6bb9cf610..1e7a75ea1cf 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Dequeues `n` tuples of one or more tensors from the given queue.
@@ -54,7 +54,7 @@
  * component of the dequeued tuple.
  */
 @Operator(group = "io")
-public final class QueueDequeueUpTo extends RawOp implements Iterable<Operand<Tensor>> {
+public final class QueueDequeueUpTo extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.QueueDequeueUpTo}
@@ -90,8 +90,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static QueueDequeueUpTo create(Scope scope, Operand<?> handle, Operand<TInt32> n, List<DataType<?>> componentTypes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueDequeueUpToV2", scope.makeOpName("QueueDequeueUpTo"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(n.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(n.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] componentTypesArray = new DataType[componentTypes.size()];
     for (int i = 0; i < componentTypesArray.length; ++i) {
@@ -126,7 +126,7 @@ public List<Output<?>> components() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) components.iterator();
   }
   
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 8bbe35eeada..25be64dc8b4 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
@@ -71,8 +71,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static QueueEnqueue create(Scope scope, Operand<?> handle, Iterable<Operand<?>> components, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueEnqueueV2", scope.makeOpName("QueueEnqueue"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(components));
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, components));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 8f973f62260..dc4fe4c7ef4 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
@@ -76,8 +76,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static QueueEnqueueMany create(Scope scope, Operand<?> handle, Iterable<Operand<?>> components, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueEnqueueManyV2", scope.makeOpName("QueueEnqueueMany"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(components));
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, components));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 0326250f5a5..388af69f2ee 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
@@ -46,7 +46,7 @@ public final class QueueIsClosed extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static QueueIsClosed create(Scope scope, Operand<?> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueIsClosedV2", scope.makeOpName("QueueIsClosed"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new QueueIsClosed(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TBool> isClosed() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return isClosed;
   }
   
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 cf904be8436..e29a9e90b87 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
@@ -43,7 +43,7 @@ public final class QueueSize extends RawOp implements Operand<TInt32> {
   @Endpoint(describeByClass = true)
   public static QueueSize create(Scope scope, Operand<?> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("QueueSizeV2", scope.makeOpName("QueueSize"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new QueueSize(opBuilder.build());
   }
@@ -56,7 +56,7 @@ public Output<TInt32> size() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return size;
   }
   
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 9b4fce26285..751fcae2f64 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,18 +23,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A queue that randomizes the order of elements.
  */
 @Operator(group = "io")
-public final class RandomShuffleQueue extends RawOp implements Operand<Tensor> {
+public final class RandomShuffleQueue extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.RandomShuffleQueue}
@@ -234,8 +234,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 9ba806c69ae..e8adea370a9 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
@@ -43,7 +43,7 @@ public final class ReadFile extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static ReadFile create(Scope scope, Operand<TString> filename) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReadFile", scope.makeOpName("ReadFile"));
-    opBuilder.addInput(filename.asOutput());
+    opBuilder.addInput(filename.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReadFile(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TString> contents() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return contents;
   }
   
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 51ec23956fb..bb9ad57ab6d 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
@@ -46,7 +46,7 @@ public final class ReaderNumRecordsProduced extends RawOp implements Operand<TIn
   @Endpoint(describeByClass = true)
   public static ReaderNumRecordsProduced create(Scope scope, Operand<?> readerHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReaderNumRecordsProducedV2", scope.makeOpName("ReaderNumRecordsProduced"));
-    opBuilder.addInput(readerHandle.asOutput());
+    opBuilder.addInput(readerHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReaderNumRecordsProduced(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TInt64> recordsProduced() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return recordsProduced;
   }
   
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 848f1602cb3..6670c4bb800 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
@@ -43,7 +43,7 @@ public final class ReaderNumWorkUnitsCompleted extends RawOp implements Operand<
   @Endpoint(describeByClass = true)
   public static ReaderNumWorkUnitsCompleted create(Scope scope, Operand<?> readerHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReaderNumWorkUnitsCompletedV2", scope.makeOpName("ReaderNumWorkUnitsCompleted"));
-    opBuilder.addInput(readerHandle.asOutput());
+    opBuilder.addInput(readerHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReaderNumWorkUnitsCompleted(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TInt64> unitsCompleted() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return unitsCompleted;
   }
   
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 33e1e7135e5..3d99b69d1a4 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
@@ -48,8 +48,8 @@ public final class ReaderRead extends RawOp {
   @Endpoint(describeByClass = true)
   public static ReaderRead create(Scope scope, Operand<?> readerHandle, Operand<?> queueHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReaderReadV2", scope.makeOpName("ReaderRead"));
-    opBuilder.addInput(readerHandle.asOutput());
-    opBuilder.addInput(queueHandle.asOutput());
+    opBuilder.addInput(readerHandle.asOutput(scope));
+    opBuilder.addInput(queueHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReaderRead(opBuilder.build());
   }
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 897ca83dc9f..a0050f53aa2 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
@@ -51,9 +51,9 @@ public final class ReaderReadUpTo extends RawOp {
   @Endpoint(describeByClass = true)
   public static ReaderReadUpTo create(Scope scope, Operand<?> readerHandle, Operand<?> queueHandle, Operand<TInt64> numRecords) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReaderReadUpToV2", scope.makeOpName("ReaderReadUpTo"));
-    opBuilder.addInput(readerHandle.asOutput());
-    opBuilder.addInput(queueHandle.asOutput());
-    opBuilder.addInput(numRecords.asOutput());
+    opBuilder.addInput(readerHandle.asOutput(scope));
+    opBuilder.addInput(queueHandle.asOutput(scope));
+    opBuilder.addInput(numRecords.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReaderReadUpTo(opBuilder.build());
   }
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 f99a25a836a..30fb72bdd6b 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
@@ -41,7 +41,7 @@ public final class ReaderReset extends RawOp {
   @Endpoint(describeByClass = true)
   public static ReaderReset create(Scope scope, Operand<?> readerHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReaderResetV2", scope.makeOpName("ReaderReset"));
-    opBuilder.addInput(readerHandle.asOutput());
+    opBuilder.addInput(readerHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReaderReset(opBuilder.build());
   }
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 359c4d63284..2f111309401 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
@@ -47,8 +47,8 @@ public final class ReaderRestoreState extends RawOp {
   @Endpoint(describeByClass = true)
   public static ReaderRestoreState create(Scope scope, Operand<?> readerHandle, Operand<TString> state) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReaderRestoreStateV2", scope.makeOpName("ReaderRestoreState"));
-    opBuilder.addInput(readerHandle.asOutput());
-    opBuilder.addInput(state.asOutput());
+    opBuilder.addInput(readerHandle.asOutput(scope));
+    opBuilder.addInput(state.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReaderRestoreState(opBuilder.build());
   }
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 d10ce99d2a8..5438d8981ea 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
@@ -46,7 +46,7 @@ public final class ReaderSerializeState extends RawOp implements Operand<TString
   @Endpoint(describeByClass = true)
   public static ReaderSerializeState create(Scope scope, Operand<?> readerHandle) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReaderSerializeStateV2", scope.makeOpName("ReaderSerializeState"));
-    opBuilder.addInput(readerHandle.asOutput());
+    opBuilder.addInput(readerHandle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReaderSerializeState(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TString> state() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return state;
   }
   
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 bad0d043f1a..7068f84a11f 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
@@ -44,7 +44,7 @@
  * @param <U> data type for {@code serializedSparse()} output
  */
 @Operator(group = "io")
-public final class SerializeManySparse<U extends Tensor> extends RawOp 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.
@@ -58,11 +58,11 @@ public final class SerializeManySparse<U extends Tensor> extends RawOp implement
    * @return a new instance of SerializeManySparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> SerializeManySparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
+  public static <U extends TType, T extends TType> SerializeManySparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("SerializeManySparse", scope.makeOpName("SerializeManySparse"));
-    opBuilder.addInput(sparseIndices.asOutput());
-    opBuilder.addInput(sparseValues.asOutput());
-    opBuilder.addInput(sparseShape.asOutput());
+    opBuilder.addInput(sparseIndices.asOutput(scope));
+    opBuilder.addInput(sparseValues.asOutput(scope));
+    opBuilder.addInput(sparseShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new SerializeManySparse<U>(opBuilder.build());
@@ -78,7 +78,7 @@ public static <U extends Tensor, T extends Tensor> SerializeManySparse<U> create
    * @return a new instance of SerializeManySparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SerializeManySparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
+  public static <T extends TType> SerializeManySparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return create(scope, sparseIndices, sparseValues, sparseShape, TString.DTYPE);
   }
   
@@ -89,7 +89,7 @@ public Output<U> serializedSparse() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return serializedSparse;
   }
   
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 41ae4f8f460..6bd707aa17e 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Serialize a `SparseTensor` into a `[3]` `Tensor` object.
@@ -36,7 +36,7 @@
  * @param <U> data type for {@code serializedSparse()} output
  */
 @Operator(group = "io")
-public final class SerializeSparse<U extends Tensor> extends RawOp 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.
@@ -50,11 +50,11 @@ public final class SerializeSparse<U extends Tensor> extends RawOp implements Op
    * @return a new instance of SerializeSparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> SerializeSparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
+  public static <U extends TType, T extends TType> SerializeSparse<U> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("SerializeSparse", scope.makeOpName("SerializeSparse"));
-    opBuilder.addInput(sparseIndices.asOutput());
-    opBuilder.addInput(sparseValues.asOutput());
-    opBuilder.addInput(sparseShape.asOutput());
+    opBuilder.addInput(sparseIndices.asOutput(scope));
+    opBuilder.addInput(sparseValues.asOutput(scope));
+    opBuilder.addInput(sparseShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new SerializeSparse<U>(opBuilder.build());
@@ -70,7 +70,7 @@ public static <U extends Tensor, T extends Tensor> SerializeSparse<U> create(Sco
    * @return a new instance of SerializeSparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SerializeSparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
+  public static <T extends TType> SerializeSparse<TString> create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape) {
     return create(scope, sparseIndices, sparseValues, sparseShape, TString.DTYPE);
   }
   
@@ -81,7 +81,7 @@ public Output<U> serializedSparse() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return serializedSparse;
   }
   
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 3c2baf1c2ac..348fe6e5a70 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Transforms a Tensor into a serialized TensorProto proto.
@@ -42,9 +42,9 @@ public final class SerializeTensor extends RawOp implements Operand<TString> {
    * @return a new instance of SerializeTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SerializeTensor create(Scope scope, Operand<T> tensor) {
+  public static <T extends TType> SerializeTensor create(Scope scope, Operand<T> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("SerializeTensor", scope.makeOpName("SerializeTensor"));
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SerializeTensor(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<TString> serialized() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return serialized;
   }
   
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 3febe213066..fdd4e0cb342 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
@@ -48,9 +48,9 @@ public final class ShardedFilename extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static ShardedFilename create(Scope scope, Operand<TString> basename, Operand<TInt32> shard, Operand<TInt32> numShards) {
     OperationBuilder opBuilder = scope.env().opBuilder("ShardedFilename", scope.makeOpName("ShardedFilename"));
-    opBuilder.addInput(basename.asOutput());
-    opBuilder.addInput(shard.asOutput());
-    opBuilder.addInput(numShards.asOutput());
+    opBuilder.addInput(basename.asOutput(scope));
+    opBuilder.addInput(shard.asOutput(scope));
+    opBuilder.addInput(numShards.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ShardedFilename(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<TString> filename() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return filename;
   }
   
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 4c414afa0a4..b651b1a614f 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
@@ -45,8 +45,8 @@ public final class ShardedFilespec extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static ShardedFilespec create(Scope scope, Operand<TString> basename, Operand<TInt32> numShards) {
     OperationBuilder opBuilder = scope.env().opBuilder("ShardedFilespec", scope.makeOpName("ShardedFilespec"));
-    opBuilder.addInput(basename.asOutput());
-    opBuilder.addInput(numShards.asOutput());
+    opBuilder.addInput(basename.asOutput(scope));
+    opBuilder.addInput(numShards.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ShardedFilespec(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TString> filename() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return filename;
   }
   
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 4e1afc17621..34608e00e56 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the lines of a file delimited by '\n'.
  */
 @Operator(group = "io")
-public final class TextLineReader extends RawOp implements Operand<Tensor> {
+public final class TextLineReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.TextLineReader}
@@ -131,8 +131,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) readerHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 cf5e15bd576..b1dad5432d2 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the records from a TensorFlow Records file.
  */
 @Operator(group = "io")
-public final class TfRecordReader extends RawOp implements Operand<Tensor> {
+public final class TfRecordReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.TfRecordReader}
@@ -131,8 +131,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) readerHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 aab3cc7a8aa..dbf5d806f4c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A Reader that outputs the entire contents of a file as a value.
@@ -34,7 +34,7 @@
  * be a filename (key) and the contents of that file (value).
  */
 @Operator(group = "io")
-public final class WholeFileReader extends RawOp implements Operand<Tensor> {
+public final class WholeFileReader extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.io.WholeFileReader}
@@ -115,8 +115,8 @@ public Output<?> readerHandle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) readerHandle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) readerHandle;
   }
   
   private Output<?> readerHandle;
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 2d8f1ed4a1b..1cad173ee74 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
@@ -45,8 +45,8 @@ public final class WriteFile extends RawOp {
   @Endpoint(describeByClass = true)
   public static WriteFile create(Scope scope, Operand<TString> filename, Operand<TString> contents) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteFile", scope.makeOpName("WriteFile"));
-    opBuilder.addInput(filename.asOutput());
-    opBuilder.addInput(contents.asOutput());
+    opBuilder.addInput(filename.asOutput(scope));
+    opBuilder.addInput(contents.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WriteFile(opBuilder.build());
   }
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 722dbde298d..41c9867b45b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Copy a tensor setting everything outside a central band in each innermost matrix
@@ -72,7 +72,7 @@
  * @param <T> data type for {@code band()} output
  */
 @Operator(group = "linalg")
-public final class BandPart<T extends Tensor> extends RawOp 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.
@@ -86,11 +86,11 @@ public final class BandPart<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of BandPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> BandPart<T> create(Scope scope, Operand<T> input, Operand<U> numLower, Operand<U> numUpper) {
+  public static <T extends TType, U extends TNumber> BandPart<T> create(Scope scope, Operand<T> input, Operand<U> numLower, Operand<U> numUpper) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixBandPart", scope.makeOpName("BandPart"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(numLower.asOutput());
-    opBuilder.addInput(numUpper.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(numLower.asOutput(scope));
+    opBuilder.addInput(numUpper.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BandPart<T>(opBuilder.build());
   }
@@ -103,7 +103,7 @@ public Output<T> band() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return band;
   }
   
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 f9c8cce0604..c5ffc3f8eec 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchCholesky<T extends Tensor & TNumber> extends RawOp 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.
@@ -42,9 +41,9 @@ public final class BatchCholesky<T extends Tensor & TNumber> extends RawOp imple
    * @return a new instance of BatchCholesky
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BatchCholesky<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TNumber> BatchCholesky<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchCholesky", scope.makeOpName("BatchCholesky"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchCholesky<T>(opBuilder.build());
   }
@@ -56,7 +55,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 26281390006..62d608aa9c2 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchCholeskyGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -43,10 +42,10 @@ public final class BatchCholeskyGrad<T extends Tensor & TNumber> extends RawOp i
    * @return a new instance of BatchCholeskyGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BatchCholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
+  public static <T extends TNumber> BatchCholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchCholeskyGrad", scope.makeOpName("BatchCholeskyGrad"));
-    opBuilder.addInput(l.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(l.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchCholeskyGrad<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 aee9afb96b0..aa6e25614ca 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,18 +21,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code band()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixBandPart<T extends Tensor> extends RawOp 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.
@@ -44,11 +44,11 @@ public final class BatchMatrixBandPart<T extends Tensor> extends RawOp implement
    * @return a new instance of BatchMatrixBandPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchMatrixBandPart<T> create(Scope scope, Operand<T> input, Operand<TInt64> numLower, Operand<TInt64> numUpper) {
+  public static <T extends TType> BatchMatrixBandPart<T> create(Scope scope, Operand<T> input, Operand<TInt64> numLower, Operand<TInt64> numUpper) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixBandPart", scope.makeOpName("BatchMatrixBandPart"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(numLower.asOutput());
-    opBuilder.addInput(numUpper.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(numLower.asOutput(scope));
+    opBuilder.addInput(numUpper.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchMatrixBandPart<T>(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<T> band() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return band;
   }
   
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 57817049d70..06f738dbf17 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDeterminant<T extends Tensor> extends RawOp 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.
@@ -41,9 +41,9 @@ public final class BatchMatrixDeterminant<T extends Tensor> extends RawOp implem
    * @return a new instance of BatchMatrixDeterminant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> BatchMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixDeterminant", scope.makeOpName("BatchMatrixDeterminant"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchMatrixDeterminant<T>(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c4765b1e656..931031c7bc2 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDiag<T extends Tensor> extends RawOp 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.
@@ -41,9 +41,9 @@ public final class BatchMatrixDiag<T extends Tensor> extends RawOp implements Op
    * @return a new instance of BatchMatrixDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchMatrixDiag<T> create(Scope scope, Operand<T> diagonal) {
+  public static <T extends TType> BatchMatrixDiag<T> create(Scope scope, Operand<T> diagonal) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixDiag", scope.makeOpName("BatchMatrixDiag"));
-    opBuilder.addInput(diagonal.asOutput());
+    opBuilder.addInput(diagonal.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchMatrixDiag<T>(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 7776b261f02..af6be14c758 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixDiagPart<T extends Tensor> extends RawOp 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.
@@ -41,9 +41,9 @@ public final class BatchMatrixDiagPart<T extends Tensor> extends RawOp implement
    * @return a new instance of BatchMatrixDiagPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchMatrixDiagPart<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> BatchMatrixDiagPart<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixDiagPart", scope.makeOpName("BatchMatrixDiagPart"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchMatrixDiagPart<T>(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<T> diagonal() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return diagonal;
   }
   
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 df9ae2a0362..1be4013bbc5 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixInverse<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixInverse<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixInverse}
@@ -62,9 +61,9 @@ private Options() {
    * @return a new instance of BatchMatrixInverse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BatchMatrixInverse<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TNumber> BatchMatrixInverse<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixInverse", scope.makeOpName("BatchMatrixInverse"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -90,7 +89,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 50fbf0989a8..a89aa017714 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSetDiag<T extends Tensor> extends RawOp 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.
@@ -42,10 +42,10 @@ public final class BatchMatrixSetDiag<T extends Tensor> extends RawOp implements
    * @return a new instance of BatchMatrixSetDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchMatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal) {
+  public static <T extends TType> BatchMatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixSetDiag", scope.makeOpName("BatchMatrixSetDiag"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(diagonal.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(diagonal.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchMatrixSetDiag<T>(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ca4bf37d4cc..c0736003ceb 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSolve<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixSolve<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixSolve}
@@ -63,10 +62,10 @@ private Options() {
    * @return a new instance of BatchMatrixSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BatchMatrixSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends TNumber> BatchMatrixSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixSolve", scope.makeOpName("BatchMatrixSolve"));
-    opBuilder.addInput(matrix.asOutput());
-    opBuilder.addInput(rhs.asOutput());
+    opBuilder.addInput(matrix.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -92,7 +91,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 d2794f4c6dd..078f615da30 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixSolveLs<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixSolveLs<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixSolveLs}
@@ -65,11 +64,11 @@ private Options() {
    * @return a new instance of BatchMatrixSolveLs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BatchMatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
+  public static <T extends TNumber> BatchMatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixSolveLs", scope.makeOpName("BatchMatrixSolveLs"));
-    opBuilder.addInput(matrix.asOutput());
-    opBuilder.addInput(rhs.asOutput());
-    opBuilder.addInput(l2Regularizer.asOutput());
+    opBuilder.addInput(matrix.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
+    opBuilder.addInput(l2Regularizer.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -95,7 +94,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 cdd2fd8c4d4..1d0be7a3200 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class BatchMatrixTriangularSolve<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class BatchMatrixTriangularSolve<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchMatrixTriangularSolve}
@@ -72,10 +71,10 @@ private Options() {
    * @return a new instance of BatchMatrixTriangularSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BatchMatrixTriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends TNumber> BatchMatrixTriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatrixTriangularSolve", scope.makeOpName("BatchMatrixTriangularSolve"));
-    opBuilder.addInput(matrix.asOutput());
-    opBuilder.addInput(rhs.asOutput());
+    opBuilder.addInput(matrix.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -111,7 +110,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 03f156733ca..d55b50eb293 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class BatchSelfAdjointEig<T extends Tensor & TNumber> extends RawOp {
+public final class BatchSelfAdjointEig<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchSelfAdjointEig}
@@ -62,9 +61,9 @@ private Options() {
    * @return a new instance of BatchSelfAdjointEig
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BatchSelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TNumber> BatchSelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchSelfAdjointEigV2", scope.makeOpName("BatchSelfAdjointEig"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 a74bfc00872..5058eff9c1d 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "linalg")
-public final class BatchSvd<T extends Tensor> extends RawOp {
+public final class BatchSvd<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.BatchSvd}
@@ -70,9 +70,9 @@ private Options() {
    * @return a new instance of BatchSvd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchSvd<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> BatchSvd<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchSvd", scope.makeOpName("BatchSvd"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 bdd1a4bc8d2..bf71ea412ae 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the Cholesky decomposition of one or more square matrices.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Cholesky<T extends Tensor> extends RawOp 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.
@@ -57,9 +57,9 @@ public final class Cholesky<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of Cholesky
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Cholesky<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Cholesky<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cholesky", scope.makeOpName("Cholesky"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Cholesky<T>(opBuilder.build());
   }
@@ -72,7 +72,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 bd762dcee34..707b02915a8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class CholeskyGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -52,10 +51,10 @@ public final class CholeskyGrad<T extends Tensor & TNumber> extends RawOp implem
    * @return a new instance of CholeskyGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
+  public static <T extends TNumber> CholeskyGrad<T> create(Scope scope, Operand<T> l, Operand<T> grad) {
     OperationBuilder opBuilder = scope.env().opBuilder("CholeskyGrad", scope.makeOpName("CholeskyGrad"));
-    opBuilder.addInput(l.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(l.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new CholeskyGrad<T>(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 50021995578..a1272fc19ef 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Shuffle dimensions of x according to a permutation and conjugate the result.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "linalg")
-public final class ConjugateTranspose<T extends Tensor> extends RawOp 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.
@@ -49,10 +49,10 @@ public final class ConjugateTranspose<T extends Tensor> extends RawOp implements
    * @return a new instance of ConjugateTranspose
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ConjugateTranspose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
+  public static <T extends TType, U extends TNumber> ConjugateTranspose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConjugateTranspose", scope.makeOpName("ConjugateTranspose"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(perm.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(perm.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ConjugateTranspose<T>(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 e2fe7c74bff..b4409e99bdb 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "linalg")
-public final class Cross<T extends Tensor & TNumber> extends RawOp 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.
@@ -49,10 +48,10 @@ public final class Cross<T extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Cross
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Cross<T> create(Scope scope, Operand<T> a, Operand<T> b) {
+  public static <T extends TNumber> Cross<T> create(Scope scope, Operand<T> a, Operand<T> b) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cross", scope.makeOpName("Cross"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Cross<T>(opBuilder.build());
   }
@@ -65,7 +64,7 @@ public Output<T> product() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return product;
   }
   
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 af0f1ac3491..ce2050bfd39 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the determinant of one or more square matrices.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Det<T extends Tensor> extends RawOp 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.
@@ -47,9 +47,9 @@ public final class Det<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Det
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Det<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Det<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDeterminant", scope.makeOpName("Det"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Det<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 f0e48f0a671..0099466a6ac 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of one or more square matrices.
@@ -46,7 +46,7 @@
  * @param <U> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class Eig<U extends Tensor> extends RawOp {
+public final class Eig<U extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Eig}
@@ -78,9 +78,9 @@ private Options() {
    * @return a new instance of Eig
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> Eig<U> create(Scope scope, Operand<T> input, DataType<U> Tout, Options... options) {
+  public static <U extends TType, T extends TType> Eig<U> create(Scope scope, Operand<T> input, DataType<U> Tout, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Eig", scope.makeOpName("Eig"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tout", Tout);
     if (options != null) {
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 5ebba7c28e1..48229fd4b92 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Tensor contraction according to Einstein summation convention.
@@ -111,7 +111,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Einsum<T extends Tensor> extends RawOp 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.
@@ -122,9 +122,9 @@ public final class Einsum<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Einsum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Einsum<T> create(Scope scope, Iterable<Operand<T>> inputs, String equation) {
+  public static <T extends TType> Einsum<T> create(Scope scope, Iterable<Operand<T>> inputs, String equation) {
     OperationBuilder opBuilder = scope.env().opBuilder("Einsum", scope.makeOpName("Einsum"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("equation", equation);
     return new Einsum<T>(opBuilder.build());
@@ -138,7 +138,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 512530ed3c2..19bc288eb8a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the euclidean norm of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class EuclideanNorm<T extends Tensor> extends RawOp implements Operand<T> {
+public final class EuclideanNorm<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.EuclideanNorm}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of EuclideanNorm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> EuclideanNorm<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> EuclideanNorm<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EuclideanNorm", scope.makeOpName("EuclideanNorm"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 46ac559d61b..a3b3c2da6d4 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the inverse of one or more square invertible matrices or their
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Inv<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Inv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Inv}
@@ -75,9 +75,9 @@ private Options() {
    * @return a new instance of Inv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Inv<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> Inv<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixInverse", scope.makeOpName("Inv"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -108,7 +108,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 58482665ed7..4b5bd40be90 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
@@ -122,11 +122,11 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadAndRemapMatrix create(Scope scope, Operand<TString> ckptPath, Operand<TString> oldTensorName, Operand<TInt64> rowRemapping, Operand<TInt64> colRemapping, Operand<TFloat32> initializingValues, Long numRows, Long numCols, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadAndRemapMatrix", scope.makeOpName("LoadAndRemapMatrix"));
-    opBuilder.addInput(ckptPath.asOutput());
-    opBuilder.addInput(oldTensorName.asOutput());
-    opBuilder.addInput(rowRemapping.asOutput());
-    opBuilder.addInput(colRemapping.asOutput());
-    opBuilder.addInput(initializingValues.asOutput());
+    opBuilder.addInput(ckptPath.asOutput(scope));
+    opBuilder.addInput(oldTensorName.asOutput(scope));
+    opBuilder.addInput(rowRemapping.asOutput(scope));
+    opBuilder.addInput(colRemapping.asOutput(scope));
+    opBuilder.addInput(initializingValues.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_rows", numRows);
     opBuilder.setAttr("num_cols", numCols);
@@ -158,7 +158,7 @@ public Output<TFloat32> outputMatrix() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return outputMatrix;
   }
   
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 4afe18f5406..111a427c11b 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sign and the log of the absolute value of the determinant of
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code sign()} output
  */
 @Operator(group = "linalg")
-public final class LogMatrixDeterminant<T extends Tensor> extends RawOp {
+public final class LogMatrixDeterminant<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LogMatrixDeterminant operation.
@@ -53,9 +53,9 @@ public final class LogMatrixDeterminant<T extends Tensor> extends RawOp {
    * @return a new instance of LogMatrixDeterminant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> LogMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> LogMatrixDeterminant<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogMatrixDeterminant", scope.makeOpName("LogMatrixDeterminant"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LogMatrixDeterminant<T>(opBuilder.build());
   }
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 85440bfeadb..cc0e5734555 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the LU decomposition of one or more square matrices.
@@ -55,7 +55,7 @@
  * @param <U> data type for {@code p()} output
  */
 @Operator(group = "linalg")
-public final class Lu<T extends Tensor, U extends Tensor & TNumber> extends RawOp {
+public final class Lu<T extends TType, U extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Lu operation.
@@ -67,9 +67,9 @@ public final class Lu<T extends Tensor, U extends Tensor & TNumber> extends RawO
    * @return a new instance of Lu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Lu<T, U> create(Scope scope, Operand<T> input, DataType<U> outputIdxType) {
+  public static <T extends TType, U extends TNumber> Lu<T, U> create(Scope scope, Operand<T> input, DataType<U> outputIdxType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Lu", scope.makeOpName("Lu"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_idx_type", outputIdxType);
     return new Lu<T, U>(opBuilder.build());
@@ -84,7 +84,7 @@ public static <T extends Tensor, U extends Tensor & TNumber> Lu<T, U> create(Sco
    * @return a new instance of Lu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Lu<T, TInt32> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Lu<T, TInt32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TInt32.DTYPE);
   }
   
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 777a2337f07..d16e2018d28 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Multiply the matrix "a" by the matrix "b".
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "linalg")
-public final class MatMul<T extends Tensor> extends RawOp implements Operand<T> {
+public final class MatMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatMul}
@@ -81,10 +81,10 @@ private Options() {
    * @return a new instance of MatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatMul<T> create(Scope scope, Operand<T> a, Operand<T> b, Options... options) {
+  public static <T extends TType> MatMul<T> create(Scope scope, Operand<T> a, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatMul", scope.makeOpName("MatMul"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -120,7 +120,7 @@ public Output<T> product() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return product;
   }
   
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 9b53396c643..1a0621c60d6 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a batched diagonal tensor with given batched diagonal values.
@@ -119,7 +119,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiag<T extends Tensor> extends RawOp 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.
@@ -141,13 +141,13 @@ public final class MatrixDiag<T extends Tensor> extends RawOp implements Operand
    * @return a new instance of MatrixDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatrixDiag<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue) {
+  public static <T extends TType> MatrixDiag<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagV2", scope.makeOpName("MatrixDiag"));
-    opBuilder.addInput(diagonal.asOutput());
-    opBuilder.addInput(k.asOutput());
-    opBuilder.addInput(numRows.asOutput());
-    opBuilder.addInput(numCols.asOutput());
-    opBuilder.addInput(paddingValue.asOutput());
+    opBuilder.addInput(diagonal.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
+    opBuilder.addInput(numRows.asOutput(scope));
+    opBuilder.addInput(numCols.asOutput(scope));
+    opBuilder.addInput(paddingValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MatrixDiag<T>(opBuilder.build());
   }
@@ -160,7 +160,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 7fcdedee707..924235aa512 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the batched diagonal part of a batched tensor.
@@ -101,7 +101,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiagPart<T extends Tensor> extends RawOp 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.
@@ -117,11 +117,11 @@ public final class MatrixDiagPart<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of MatrixDiagPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatrixDiagPart<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue) {
+  public static <T extends TType> MatrixDiagPart<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagPartV2", scope.makeOpName("MatrixDiagPart"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(k.asOutput());
-    opBuilder.addInput(paddingValue.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
+    opBuilder.addInput(paddingValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MatrixDiagPart<T>(opBuilder.build());
   }
@@ -134,7 +134,7 @@ public Output<T> diagonal() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return diagonal;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java
index 77c76cea5bb..15d8b8bdbc6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagPartV3.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the batched diagonal part of a batched tensor.
@@ -132,7 +132,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiagPartV3<T extends Tensor> extends RawOp implements Operand<T> {
+public final class MatrixDiagPartV3<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixDiagPartV3}
@@ -174,11 +174,11 @@ private Options() {
    * @return a new instance of MatrixDiagPartV3
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatrixDiagPartV3<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue, Options... options) {
+  public static <T extends TType> MatrixDiagPartV3<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Operand<T> paddingValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagPartV3", scope.makeOpName("MatrixDiagPartV3"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(k.asOutput());
-    opBuilder.addInput(paddingValue.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
+    opBuilder.addInput(paddingValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -211,7 +211,7 @@ public Output<T> diagonal() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return diagonal;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java
index 861955e4d32..71ba07cdc96 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/linalg/MatrixDiagV3.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a batched diagonal tensor with given batched diagonal values.
@@ -148,7 +148,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixDiagV3<T extends Tensor> extends RawOp implements Operand<T> {
+public final class MatrixDiagV3<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixDiagV3}
@@ -196,13 +196,13 @@ private Options() {
    * @return a new instance of MatrixDiagV3
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatrixDiagV3<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue, Options... options) {
+  public static <T extends TType> MatrixDiagV3<T> create(Scope scope, Operand<T> diagonal, Operand<TInt32> k, Operand<TInt32> numRows, Operand<TInt32> numCols, Operand<T> paddingValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixDiagV3", scope.makeOpName("MatrixDiagV3"));
-    opBuilder.addInput(diagonal.asOutput());
-    opBuilder.addInput(k.asOutput());
-    opBuilder.addInput(numRows.asOutput());
-    opBuilder.addInput(numCols.asOutput());
-    opBuilder.addInput(paddingValue.asOutput());
+    opBuilder.addInput(diagonal.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
+    opBuilder.addInput(numRows.asOutput(scope));
+    opBuilder.addInput(numCols.asOutput(scope));
+    opBuilder.addInput(paddingValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -235,7 +235,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 d70127b110c..bf3bf872def 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the matrix logarithm of one or more square matrices:
@@ -48,7 +48,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MatrixLogarithm<T extends Tensor> extends RawOp 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.
@@ -58,9 +58,9 @@ public final class MatrixLogarithm<T extends Tensor> extends RawOp implements Op
    * @return a new instance of MatrixLogarithm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatrixLogarithm<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> MatrixLogarithm<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixLogarithm", scope.makeOpName("MatrixLogarithm"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MatrixLogarithm<T>(opBuilder.build());
   }
@@ -77,7 +77,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 e0e390da25c..a7a1f105c03 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a batched matrix tensor with new batched diagonal values.
@@ -136,7 +136,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixSetDiag<T extends Tensor> extends RawOp implements Operand<T> {
+public final class MatrixSetDiag<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixSetDiag}
@@ -178,11 +178,11 @@ private Options() {
    * @return a new instance of MatrixSetDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal, Operand<TInt32> k, Options... options) {
+  public static <T extends TType> MatrixSetDiag<T> create(Scope scope, Operand<T> input, Operand<T> diagonal, Operand<TInt32> k, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSetDiagV3", scope.makeOpName("MatrixSetDiag"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(diagonal.asOutput());
-    opBuilder.addInput(k.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(diagonal.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -215,7 +215,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 8a52a345bcb..d04762be657 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Solves one or more linear least-squares problems.
@@ -69,7 +69,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class MatrixSolveLs<T extends Tensor> extends RawOp implements Operand<T> {
+public final class MatrixSolveLs<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.MatrixSolveLs}
@@ -105,11 +105,11 @@ private Options() {
    * @return a new instance of MatrixSolveLs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
+  public static <T extends TType> MatrixSolveLs<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Operand<TFloat64> l2Regularizer, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSolveLs", scope.makeOpName("MatrixSolveLs"));
-    opBuilder.addInput(matrix.asOutput());
-    opBuilder.addInput(rhs.asOutput());
-    opBuilder.addInput(l2Regularizer.asOutput());
+    opBuilder.addInput(matrix.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
+    opBuilder.addInput(l2Regularizer.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -136,7 +136,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 9eaa3fa01e1..0c47eeeaca5 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the QR decompositions of one or more matrices.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code q()} output
  */
 @Operator(group = "linalg")
-public final class Qr<T extends Tensor> extends RawOp {
+public final class Qr<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Qr}
@@ -76,9 +76,9 @@ private Options() {
    * @return a new instance of Qr
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Qr<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> Qr<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Qr", scope.makeOpName("Qr"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 d6b08f0184e..c3c7233c2be 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Perform a quantized matrix multiplication of  `a` by the matrix `b`.
@@ -40,7 +40,7 @@
  * @param <V> data type for {@code out()} output
  */
 @Operator(group = "linalg")
-public final class QuantizedMatMul<V extends Tensor> extends RawOp {
+public final class QuantizedMatMul<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMul}
@@ -87,14 +87,14 @@ private Options() {
    * @return a new instance of QuantizedMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor, W extends Tensor> QuantizedMatMul<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, DataType<W> Tactivation, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType, W extends TType> QuantizedMatMul<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, DataType<W> Tactivation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMul", scope.makeOpName("QuantizedMatMul"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(minA.asOutput());
-    opBuilder.addInput(maxA.asOutput());
-    opBuilder.addInput(minB.asOutput());
-    opBuilder.addInput(maxB.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(minA.asOutput(scope));
+    opBuilder.addInput(maxA.asOutput(scope));
+    opBuilder.addInput(minB.asOutput(scope));
+    opBuilder.addInput(maxB.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     opBuilder.setAttr("Tactivation", Tactivation);
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 9fb6eb388e8..16726d15117 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Performs a quantized matrix multiplication of `a` by the matrix `b` with bias
@@ -41,7 +41,7 @@
  * 
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBias<W extends Tensor> extends RawOp {
+public final class QuantizedMatMulWithBias<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBias}
@@ -97,15 +97,15 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBias
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBias<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<W> Toutput, Options... options) {
+  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBias<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBias", scope.makeOpName("QuantizedMatMulWithBias"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minA.asOutput());
-    opBuilder.addInput(maxA.asOutput());
-    opBuilder.addInput(minB.asOutput());
-    opBuilder.addInput(maxB.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minA.asOutput(scope));
+    opBuilder.addInput(maxA.asOutput(scope));
+    opBuilder.addInput(minB.asOutput(scope));
+    opBuilder.addInput(maxB.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     if (options != null) {
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 c6222beb77e..483d6ae3ec2 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Perform a quantized matrix multiplication of  `a` by the matrix `b` with bias
@@ -42,7 +42,7 @@
  * 
  * @param <V> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndRelu<V extends Tensor> extends RawOp {
+public final class QuantizedMatMulWithBiasAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBiasAndRelu}
@@ -98,15 +98,15 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedMatMulWithBiasAndRelu<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedMatMulWithBiasAndRelu<V> create(Scope scope, Operand<T> a, Operand<U> b, Operand<TFloat32> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, DataType<V> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndRelu", scope.makeOpName("QuantizedMatMulWithBiasAndRelu"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minA.asOutput());
-    opBuilder.addInput(maxA.asOutput());
-    opBuilder.addInput(minB.asOutput());
-    opBuilder.addInput(maxB.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minA.asOutput(scope));
+    opBuilder.addInput(maxA.asOutput(scope));
+    opBuilder.addInput(minB.asOutput(scope));
+    opBuilder.addInput(maxB.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     if (options != null) {
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 a5080d093a3..b2e26186ac6 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Perform a quantized matrix multiplication of  `a` by the matrix `b` with bias
@@ -43,7 +43,7 @@
  * 
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndReluAndRequantize<W extends Tensor> extends RawOp {
+public final class QuantizedMatMulWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.QuantizedMatMulWithBiasAndReluAndRequantize}
@@ -101,17 +101,17 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
+  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndReluAndRequantize", scope.makeOpName("QuantizedMatMulWithBiasAndReluAndRequantize"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minA.asOutput());
-    opBuilder.addInput(maxA.asOutput());
-    opBuilder.addInput(minB.asOutput());
-    opBuilder.addInput(maxB.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minA.asOutput(scope));
+    opBuilder.addInput(maxA.asOutput(scope));
+    opBuilder.addInput(minB.asOutput(scope));
+    opBuilder.addInput(maxB.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     if (options != null) {
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 4257b52df16..8ee5a7fdb13 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of one or more square self-adjoint matrices.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code e()} output
  */
 @Operator(group = "linalg")
-public final class SelfAdjointEig<T extends Tensor> extends RawOp {
+public final class SelfAdjointEig<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.SelfAdjointEig}
@@ -76,9 +76,9 @@ private Options() {
    * @return a new instance of SelfAdjointEig
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> SelfAdjointEig<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SelfAdjointEigV2", scope.makeOpName("SelfAdjointEig"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 6add924f912..f492bbcc6da 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Solves systems of linear equations.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Solve<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Solve<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Solve}
@@ -72,10 +72,10 @@ private Options() {
    * @return a new instance of Solve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Solve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends TType> Solve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSolve", scope.makeOpName("Solve"));
-    opBuilder.addInput(matrix.asOutput());
-    opBuilder.addInput(rhs.asOutput());
+    opBuilder.addInput(matrix.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -103,7 +103,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 b628c847316..e22ee3ea09c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the matrix square root of one or more square matrices:
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class Sqrtm<T extends Tensor> extends RawOp 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.
@@ -59,9 +59,9 @@ public final class Sqrtm<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Sqrtm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sqrtm<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Sqrtm<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixSquareRoot", scope.makeOpName("Sqrtm"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sqrtm<T>(opBuilder.build());
   }
@@ -78,7 +78,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 02570b12a65..e9d3107b592 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the singular value decompositions of one or more matrices.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "linalg")
-public final class Svd<T extends Tensor> extends RawOp {
+public final class Svd<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.Svd}
@@ -89,9 +89,9 @@ private Options() {
    * @return a new instance of Svd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Svd<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> Svd<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Svd", scope.makeOpName("Svd"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 10ef41e2b04..79c9b8b0817 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns a diagonal tensor with a given diagonal values.
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class TensorDiag<T extends Tensor> extends RawOp 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.
@@ -61,9 +61,9 @@ public final class TensorDiag<T extends Tensor> extends RawOp implements Operand
    * @return a new instance of TensorDiag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorDiag<T> create(Scope scope, Operand<T> diagonal) {
+  public static <T extends TType> TensorDiag<T> create(Scope scope, Operand<T> diagonal) {
     OperationBuilder opBuilder = scope.env().opBuilder("Diag", scope.makeOpName("TensorDiag"));
-    opBuilder.addInput(diagonal.asOutput());
+    opBuilder.addInput(diagonal.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorDiag<T>(opBuilder.build());
   }
@@ -75,7 +75,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 825a182d290..cda3b55e6a3 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the diagonal part of the tensor.
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code diagonal()} output
  */
 @Operator(group = "linalg")
-public final class TensorDiagPart<T extends Tensor> extends RawOp 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.
@@ -62,9 +62,9 @@ public final class TensorDiagPart<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of TensorDiagPart
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorDiagPart<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> TensorDiagPart<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("DiagPart", scope.makeOpName("TensorDiagPart"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorDiagPart<T>(opBuilder.build());
   }
@@ -77,7 +77,7 @@ public Output<T> diagonal() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return diagonal;
   }
   
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 2e9818da3dd..48be84db8fb 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Shuffle dimensions of x according to a permutation.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "linalg")
-public final class Transpose<T extends Tensor> extends RawOp 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.
@@ -48,10 +48,10 @@ public final class Transpose<T extends Tensor> extends RawOp implements Operand<
    * @return a new instance of Transpose
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Transpose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
+  public static <T extends TType, U extends TNumber> Transpose<T> create(Scope scope, Operand<T> x, Operand<U> perm) {
     OperationBuilder opBuilder = scope.env().opBuilder("Transpose", scope.makeOpName("Transpose"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(perm.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(perm.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Transpose<T>(opBuilder.build());
   }
@@ -63,7 +63,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 bba2206dc79..5bb07bb3991 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Solves systems of linear equations with upper or lower triangular matrices by backsubstitution.
@@ -80,7 +80,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "linalg")
-public final class TriangularSolve<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TriangularSolve<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.TriangularSolve}
@@ -126,10 +126,10 @@ private Options() {
    * @return a new instance of TriangularSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
+  public static <T extends TType> TriangularSolve<T> create(Scope scope, Operand<T> matrix, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MatrixTriangularSolve", scope.makeOpName("TriangularSolve"));
-    opBuilder.addInput(matrix.asOutput());
-    opBuilder.addInput(rhs.asOutput());
+    opBuilder.addInput(matrix.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -172,7 +172,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 4ba3843728a..f95fbbce959 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Calculate product with tridiagonal matrix.
@@ -34,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TridiagonalMatMul<T extends Tensor> extends RawOp 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.
@@ -51,12 +51,12 @@ public final class TridiagonalMatMul<T extends Tensor> extends RawOp implements
    * @return a new instance of TridiagonalMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TridiagonalMatMul<T> create(Scope scope, Operand<T> superdiag, Operand<T> maindiag, Operand<T> subdiag, Operand<T> rhs) {
+  public static <T extends TType> TridiagonalMatMul<T> create(Scope scope, Operand<T> superdiag, Operand<T> maindiag, Operand<T> subdiag, Operand<T> rhs) {
     OperationBuilder opBuilder = scope.env().opBuilder("TridiagonalMatMul", scope.makeOpName("TridiagonalMatMul"));
-    opBuilder.addInput(superdiag.asOutput());
-    opBuilder.addInput(maindiag.asOutput());
-    opBuilder.addInput(subdiag.asOutput());
-    opBuilder.addInput(rhs.asOutput());
+    opBuilder.addInput(superdiag.asOutput(scope));
+    opBuilder.addInput(maindiag.asOutput(scope));
+    opBuilder.addInput(subdiag.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TridiagonalMatMul<T>(opBuilder.build());
   }
@@ -69,7 +69,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 10d4a588f20..8f8a745fd43 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Solves tridiagonal systems of equations.
@@ -39,7 +39,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TridiagonalSolve<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TridiagonalSolve<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.TridiagonalSolve}
@@ -75,10 +75,10 @@ private Options() {
    * @return a new instance of TridiagonalSolve
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TridiagonalSolve<T> create(Scope scope, Operand<T> diagonals, Operand<T> rhs, Options... options) {
+  public static <T extends TType> TridiagonalSolve<T> create(Scope scope, Operand<T> diagonals, Operand<T> rhs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TridiagonalSolve", scope.makeOpName("TridiagonalSolve"));
-    opBuilder.addInput(diagonals.asOutput());
-    opBuilder.addInput(rhs.asOutput());
+    opBuilder.addInput(diagonals.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -106,7 +106,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 210c051483d..371e985fb19 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reads out the CSR components at batch `index`.
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code values()} output
  */
-public final class CSRSparseMatrixComponents<T extends Tensor> extends RawOp {
+public final class CSRSparseMatrixComponents<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixComponents operation.
@@ -49,10 +49,10 @@ public final class CSRSparseMatrixComponents<T extends Tensor> extends RawOp {
    * @return a new instance of CSRSparseMatrixComponents
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> CSRSparseMatrixComponents<T> create(Scope scope, Operand<?> csrSparseMatrix, Operand<TInt32> index, DataType<T> type) {
+  public static <T extends TType> CSRSparseMatrixComponents<T> create(Scope scope, Operand<?> csrSparseMatrix, Operand<TInt32> index, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("CSRSparseMatrixComponents", scope.makeOpName("CSRSparseMatrixComponents"));
-    opBuilder.addInput(csrSparseMatrix.asOutput());
-    opBuilder.addInput(index.asOutput());
+    opBuilder.addInput(csrSparseMatrix.asOutput(scope));
+    opBuilder.addInput(index.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new CSRSparseMatrixComponents<T>(opBuilder.build());
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 4f9751b6b0e..2256538721b 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,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Convert a (possibly batched) CSRSparseMatrix to dense.
  * 
  * @param <T> data type for {@code denseOutput()} output
  */
-public final class CSRSparseMatrixToDense<T extends Tensor> extends RawOp 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.
@@ -44,9 +44,9 @@ public final class CSRSparseMatrixToDense<T extends Tensor> extends RawOp implem
    * @return a new instance of CSRSparseMatrixToDense
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> CSRSparseMatrixToDense<T> create(Scope scope, Operand<?> sparseInput, DataType<T> type) {
+  public static <T extends TType> CSRSparseMatrixToDense<T> create(Scope scope, Operand<?> sparseInput, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("CSRSparseMatrixToDense", scope.makeOpName("CSRSparseMatrixToDense"));
-    opBuilder.addInput(sparseInput.asOutput());
+    opBuilder.addInput(sparseInput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new CSRSparseMatrixToDense<T>(opBuilder.build());
@@ -60,7 +60,7 @@ public Output<T> denseOutput() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return denseOutput;
   }
   
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 d66d4412490..5894ad750cb 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts a (possibly batched) CSRSparesMatrix to a SparseTensor.
  * 
  * @param <T> data type for {@code values()} output
  */
-public final class CSRSparseMatrixToSparseTensor<T extends Tensor> extends RawOp {
+public final class CSRSparseMatrixToSparseTensor<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new CSRSparseMatrixToSparseTensor operation.
@@ -45,9 +45,9 @@ public final class CSRSparseMatrixToSparseTensor<T extends Tensor> extends RawOp
    * @return a new instance of CSRSparseMatrixToSparseTensor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> CSRSparseMatrixToSparseTensor<T> create(Scope scope, Operand<?> sparseMatrix, DataType<T> type) {
+  public static <T extends TType> CSRSparseMatrixToSparseTensor<T> create(Scope scope, Operand<?> sparseMatrix, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("CSRSparseMatrixToSparseTensor", scope.makeOpName("CSRSparseMatrixToSparseTensor"));
-    opBuilder.addInput(sparseMatrix.asOutput());
+    opBuilder.addInput(sparseMatrix.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new CSRSparseMatrixToSparseTensor<T>(opBuilder.build());
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 c8bda5f9212..f0c8acbdac8 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts a dense tensor to a (possibly batched) CSRSparseMatrix.
  */
-public final class DenseToCSRSparseMatrix extends RawOp implements Operand<Tensor> {
+public final class DenseToCSRSparseMatrix extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new DenseToCSRSparseMatrix operation.
@@ -42,10 +42,10 @@ public final class DenseToCSRSparseMatrix extends RawOp implements Operand<Tenso
    * @return a new instance of DenseToCSRSparseMatrix
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DenseToCSRSparseMatrix create(Scope scope, Operand<T> denseInput, Operand<TInt64> indices) {
+  public static <T extends TType> DenseToCSRSparseMatrix create(Scope scope, Operand<T> denseInput, Operand<TInt64> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("DenseToCSRSparseMatrix", scope.makeOpName("DenseToCSRSparseMatrix"));
-    opBuilder.addInput(denseInput.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(denseInput.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DenseToCSRSparseMatrix(opBuilder.build());
   }
@@ -59,8 +59,8 @@ public Output<?> sparseOutput() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) sparseOutput;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) sparseOutput;
   }
   
   private Output<?> sparseOutput;
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 47179a5c9ce..dbcd0f94623 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sparse addition of two CSR matrices, C = alpha * A + beta * B.
@@ -33,7 +33,7 @@
  * The gradients of SparseMatrixAdd outputs with respect to alpha and beta are not
  * currently defined (TensorFlow will return zeros for these entries).
  */
-public final class SparseMatrixAdd extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixAdd extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixAdd operation.
@@ -46,12 +46,12 @@ public final class SparseMatrixAdd extends RawOp implements Operand<Tensor> {
    * @return a new instance of SparseMatrixAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseMatrixAdd create(Scope scope, Operand<?> a, Operand<?> b, Operand<T> alpha, Operand<T> beta) {
+  public static <T extends TType> SparseMatrixAdd create(Scope scope, Operand<?> a, Operand<?> b, Operand<T> alpha, Operand<T> beta) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixAdd", scope.makeOpName("SparseMatrixAdd"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(beta.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(beta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseMatrixAdd(opBuilder.build());
   }
@@ -65,8 +65,8 @@ public Output<?> c() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) c;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) c;
   }
   
   private Output<?> c;
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 00ef65841d7..521542dbb55 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Matrix-multiplies a sparse matrix with a dense matrix.
@@ -57,7 +57,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class SparseMatrixMatMul<T extends Tensor> extends RawOp 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}
@@ -133,10 +133,10 @@ private Options() {
    * @return a new instance of SparseMatrixMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseMatrixMatMul<T> create(Scope scope, Operand<?> a, Operand<T> b, Options... options) {
+  public static <T extends TType> SparseMatrixMatMul<T> create(Scope scope, Operand<?> a, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixMatMul", scope.makeOpName("SparseMatrixMatMul"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -213,7 +213,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 dc0167402b7..ee4843090f3 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Element-wise multiplication of a sparse matrix with a dense tensor.
@@ -39,7 +39,7 @@
  * <b>NOTE</b> even if `b` is zero, the sparsity structure of the output does not
  * change.
  */
-public final class SparseMatrixMul extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixMul extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixMul operation.
@@ -50,10 +50,10 @@ public final class SparseMatrixMul extends RawOp implements Operand<Tensor> {
    * @return a new instance of SparseMatrixMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseMatrixMul create(Scope scope, Operand<?> a, Operand<T> b) {
+  public static <T extends TType> SparseMatrixMul create(Scope scope, Operand<?> a, Operand<T> b) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixMul", scope.makeOpName("SparseMatrixMul"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseMatrixMul(opBuilder.build());
   }
@@ -67,8 +67,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 613228d6272..810a5d4856b 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
@@ -42,7 +42,7 @@ public final class SparseMatrixNNZ extends RawOp implements Operand<TInt32> {
   @Endpoint(describeByClass = true)
   public static SparseMatrixNNZ create(Scope scope, Operand<?> sparseMatrix) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixNNZ", scope.makeOpName("SparseMatrixNNZ"));
-    opBuilder.addInput(sparseMatrix.asOutput());
+    opBuilder.addInput(sparseMatrix.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseMatrixNNZ(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TInt32> nnz() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return nnz;
   }
   
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 9acf649aa94..0f95397cb75 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
@@ -90,7 +90,7 @@ public final class SparseMatrixOrderingAMD extends RawOp implements Operand<TInt
   @Endpoint(describeByClass = true)
   public static SparseMatrixOrderingAMD create(Scope scope, Operand<?> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixOrderingAMD", scope.makeOpName("SparseMatrixOrderingAMD"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseMatrixOrderingAMD(opBuilder.build());
   }
@@ -103,7 +103,7 @@ public Output<TInt32> output() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return output;
   }
   
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 29d1b3cbe2c..fa9b213c97d 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Calculates the softmax of a CSRSparseMatrix.
@@ -38,7 +38,7 @@
  * the output has the same sparsity structure as the input (though missing values
  * in the output may now be treated as having probability zero).
  */
-public final class SparseMatrixSoftmax extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixSoftmax extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSoftmax operation.
@@ -49,9 +49,9 @@ public final class SparseMatrixSoftmax extends RawOp implements Operand<Tensor>
    * @return a new instance of SparseMatrixSoftmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SparseMatrixSoftmax create(Scope scope, Operand<?> logits, DataType<T> type) {
+  public static <T extends TNumber> SparseMatrixSoftmax create(Scope scope, Operand<?> logits, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSoftmax", scope.makeOpName("SparseMatrixSoftmax"));
-    opBuilder.addInput(logits.asOutput());
+    opBuilder.addInput(logits.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new SparseMatrixSoftmax(opBuilder.build());
@@ -66,8 +66,8 @@ public Output<?> softmax() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) softmax;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) softmax;
   }
   
   private Output<?> softmax;
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 0e5c5d62a14..114d50a10e5 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,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Calculates the gradient of the SparseMatrixSoftmax op.
  */
-public final class SparseMatrixSoftmaxGrad extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixSoftmaxGrad extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSoftmaxGrad operation.
@@ -44,10 +44,10 @@ public final class SparseMatrixSoftmaxGrad extends RawOp implements Operand<Tens
    * @return a new instance of SparseMatrixSoftmaxGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SparseMatrixSoftmaxGrad create(Scope scope, Operand<?> softmax, Operand<?> gradSoftmax, DataType<T> type) {
+  public static <T extends TNumber> SparseMatrixSoftmaxGrad create(Scope scope, Operand<?> softmax, Operand<?> gradSoftmax, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSoftmaxGrad", scope.makeOpName("SparseMatrixSoftmaxGrad"));
-    opBuilder.addInput(softmax.asOutput());
-    opBuilder.addInput(gradSoftmax.asOutput());
+    opBuilder.addInput(softmax.asOutput(scope));
+    opBuilder.addInput(gradSoftmax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new SparseMatrixSoftmaxGrad(opBuilder.build());
@@ -62,8 +62,8 @@ public Output<?> gradient() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) gradient;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) gradient;
   }
   
   private Output<?> gradient;
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 3af4a96dc60..53c719fd496 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sparse Cholesky decomposition of `input`.
@@ -103,7 +103,7 @@
  * permutation: A `Tensor`.
  * type: The type of `input`.
  */
-public final class SparseMatrixSparseCholesky extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixSparseCholesky extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixSparseCholesky operation.
@@ -115,10 +115,10 @@ public final class SparseMatrixSparseCholesky extends RawOp implements Operand<T
    * @return a new instance of SparseMatrixSparseCholesky
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseMatrixSparseCholesky create(Scope scope, Operand<?> input, Operand<TInt32> permutation, DataType<T> type) {
+  public static <T extends TType> SparseMatrixSparseCholesky create(Scope scope, Operand<?> input, Operand<TInt32> permutation, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSparseCholesky", scope.makeOpName("SparseMatrixSparseCholesky"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(permutation.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(permutation.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new SparseMatrixSparseCholesky(opBuilder.build());
@@ -133,8 +133,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 475c378eefa..2053c365be5 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sparse-matrix-multiplies two CSR matrices `a` and `b`.
@@ -104,7 +104,7 @@
  * adjoint_a: If True, `a` adjointed before multiplication.
  * adjoint_b: If True, `b` adjointed before multiplication.
  */
-public final class SparseMatrixSparseMatMul extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixSparseMatMul extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixSparseMatMul}
@@ -163,10 +163,10 @@ private Options() {
    * @return a new instance of SparseMatrixSparseMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseMatrixSparseMatMul create(Scope scope, Operand<?> a, Operand<?> b, DataType<T> type, Options... options) {
+  public static <T extends TType> SparseMatrixSparseMatMul create(Scope scope, Operand<?> a, Operand<?> b, DataType<T> type, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixSparseMatMul", scope.makeOpName("SparseMatrixSparseMatMul"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     if (options != null) {
@@ -225,8 +225,8 @@ public Output<?> c() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) c;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) c;
   }
   
   private Output<?> c;
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 01b03a306cf..560b0c08abd 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,11 +22,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Transposes the inner (matrix) dimensions of a CSRSparseMatrix.
@@ -34,7 +34,7 @@
  * Transposes the inner (matrix) dimensions of a SparseMatrix and optionally
  * conjugates its values.
  */
-public final class SparseMatrixTranspose extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixTranspose extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.linalg.sparse.SparseMatrixTranspose}
@@ -65,9 +65,9 @@ private Options() {
    * @return a new instance of SparseMatrixTranspose
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseMatrixTranspose create(Scope scope, Operand<?> input, DataType<T> type, Options... options) {
+  public static <T extends TType> SparseMatrixTranspose create(Scope scope, Operand<?> input, DataType<T> type, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixTranspose", scope.makeOpName("SparseMatrixTranspose"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     if (options != null) {
@@ -96,8 +96,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 33a074d6a38..3ade941153b 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,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Creates an all-zeros CSRSparseMatrix with shape `dense_shape`.
  */
-public final class SparseMatrixZeros extends RawOp implements Operand<Tensor> {
+public final class SparseMatrixZeros extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseMatrixZeros operation.
@@ -43,9 +43,9 @@ public final class SparseMatrixZeros extends RawOp implements Operand<Tensor> {
    * @return a new instance of SparseMatrixZeros
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseMatrixZeros create(Scope scope, Operand<TInt64> denseShape, DataType<T> type) {
+  public static <T extends TType> SparseMatrixZeros create(Scope scope, Operand<TInt64> denseShape, DataType<T> type) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatrixZeros", scope.makeOpName("SparseMatrixZeros"));
-    opBuilder.addInput(denseShape.asOutput());
+    opBuilder.addInput(denseShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("type", type);
     return new SparseMatrixZeros(opBuilder.build());
@@ -60,8 +60,8 @@ public Output<?> sparseMatrix() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) sparseMatrix;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) sparseMatrix;
   }
   
   private Output<?> sparseMatrix;
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 0b22684d38c..1e89f5ee4a8 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,17 +21,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts a SparseTensor to a (possibly batched) CSRSparseMatrix.
  */
-public final class SparseTensorToCSRSparseMatrix extends RawOp implements Operand<Tensor> {
+public final class SparseTensorToCSRSparseMatrix extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new SparseTensorToCSRSparseMatrix operation.
@@ -43,11 +43,11 @@ public final class SparseTensorToCSRSparseMatrix extends RawOp implements Operan
    * @return a new instance of SparseTensorToCSRSparseMatrix
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseTensorToCSRSparseMatrix create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
+  public static <T extends TType> SparseTensorToCSRSparseMatrix create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorToCSRSparseMatrix", scope.makeOpName("SparseTensorToCSRSparseMatrix"));
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(values.asOutput());
-    opBuilder.addInput(denseShape.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
+    opBuilder.addInput(denseShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseTensorToCSRSparseMatrix(opBuilder.build());
   }
@@ -61,8 +61,8 @@ public Output<?> sparseMatrix() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) sparseMatrix;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) sparseMatrix;
   }
   
   private Output<?> sparseMatrix;
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 a297e6dcae0..c3b72319f43 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Abs<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,9 +47,9 @@ public final class Abs<T extends Tensor & TNumber> extends RawOp implements Oper
    * @return a new instance of Abs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Abs<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Abs<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Abs", scope.makeOpName("Abs"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Abs<T>(opBuilder.build());
   }
@@ -62,7 +61,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 3c67af8b65b..2043aef98f1 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the element-wise sum of a list of tensors.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code sum()} output
  */
 @Operator(group = "math")
-public final class AccumulateN<T extends Tensor> extends RawOp 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.
@@ -55,9 +55,9 @@ public final class AccumulateN<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of AccumulateN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AccumulateN<T> create(Scope scope, Iterable<Operand<T>> inputs, Shape shape) {
+  public static <T extends TType> AccumulateN<T> create(Scope scope, Iterable<Operand<T>> inputs, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulateNV2", scope.makeOpName("AccumulateN"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("shape", shape);
     return new AccumulateN<T>(opBuilder.build());
@@ -70,7 +70,7 @@ public Output<T> sum() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return sum;
   }
   
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 1b3102d6005..05a47881120 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes acos of x element-wise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Acos<T extends Tensor> extends RawOp 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.
@@ -43,9 +43,9 @@ public final class Acos<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Acos
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Acos<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Acos<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Acos", scope.makeOpName("Acos"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Acos<T>(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 e1c13a90b01..951a9f21021 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes inverse hyperbolic cosine of x element-wise.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Acosh<T extends Tensor> extends RawOp 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.
@@ -51,9 +51,9 @@ public final class Acosh<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Acosh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Acosh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Acosh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Acosh", scope.makeOpName("Acosh"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Acosh<T>(opBuilder.build());
   }
@@ -65,7 +65,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 25d32e0bb77..8b55b052933 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x + y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Add<T extends Tensor> extends RawOp 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.
@@ -47,10 +47,10 @@ public final class Add<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Add
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Add<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Add<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Add", scope.makeOpName("Add"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Add<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 f5eab8b9c57..5d38eb62e7a 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Add all input tensors element wise.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code sum()} output
  */
 @Operator(group = "math")
-public final class AddN<T extends Tensor> extends RawOp 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.
@@ -52,9 +52,9 @@ public final class AddN<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of AddN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AddN<T> create(Scope scope, Iterable<Operand<T>> inputs) {
+  public static <T extends TType> AddN<T> create(Scope scope, Iterable<Operand<T>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("AddN", scope.makeOpName("AddN"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AddN<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> sum() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return sum;
   }
   
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 14793f50b90..a69a70842c8 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the argument of a complex number.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Angle<U extends Tensor & TNumber> extends RawOp 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.
@@ -63,9 +63,9 @@ public final class Angle<U extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Angle
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Angle<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
+  public static <U extends TNumber, T extends TType> Angle<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Angle", scope.makeOpName("Angle"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tout", Tout);
     return new Angle<U>(opBuilder.build());
@@ -79,7 +79,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Angle<U> create(Sco
    * @return a new instance of Angle
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Angle<TFloat32> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Angle<TFloat32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TFloat32.DTYPE);
   }
   
@@ -90,7 +90,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 9cd2d5402f5..92a0a84b0df 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of abs(x-y) < tolerance element-wise.
@@ -63,10 +63,10 @@ private Options() {
    * @return a new instance of ApproximateEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApproximateEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends TType> ApproximateEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApproximateEqual", scope.makeOpName("ApproximateEqual"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -92,7 +92,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 49374ebb4f0..1213690ad73 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the index with the largest value across dimensions of a tensor.
@@ -49,7 +49,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class ArgMax<V extends Tensor & TNumber> extends RawOp 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.
@@ -63,10 +63,10 @@ public final class ArgMax<V extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of ArgMax
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMax<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
+  public static <V extends TNumber, T extends TType, U extends TNumber> ArgMax<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ArgMax", scope.makeOpName("ArgMax"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(dimension.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(dimension.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_type", outputType);
     return new ArgMax<V>(opBuilder.build());
@@ -83,7 +83,7 @@ public static <V extends Tensor & TNumber, T extends Tensor, U extends Tensor &
    * @return a new instance of ArgMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ArgMax<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
+  public static <T extends TType, U extends TNumber> ArgMax<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
     return create(scope, input, dimension, TInt64.DTYPE);
   }
   
@@ -94,7 +94,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 a31a942d01e..d789f609eb0 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the index with the smallest value across dimensions of a tensor.
@@ -49,7 +49,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class ArgMin<V extends Tensor & TNumber> extends RawOp 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.
@@ -63,10 +63,10 @@ public final class ArgMin<V extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of ArgMin
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor, U extends Tensor & TNumber> ArgMin<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
+  public static <V extends TNumber, T extends TType, U extends TNumber> ArgMin<V> create(Scope scope, Operand<T> input, Operand<U> dimension, DataType<V> outputType) {
     OperationBuilder opBuilder = scope.env().opBuilder("ArgMin", scope.makeOpName("ArgMin"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(dimension.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(dimension.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_type", outputType);
     return new ArgMin<V>(opBuilder.build());
@@ -83,7 +83,7 @@ public static <V extends Tensor & TNumber, T extends Tensor, U extends Tensor &
    * @return a new instance of ArgMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ArgMin<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
+  public static <T extends TType, U extends TNumber> ArgMin<TInt64> create(Scope scope, Operand<T> input, Operand<U> dimension) {
     return create(scope, input, dimension, TInt64.DTYPE);
   }
   
@@ -94,7 +94,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 efe680b873a..64e98a18823 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the trignometric inverse sine of x element-wise.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Asin<T extends Tensor> extends RawOp 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.
@@ -59,9 +59,9 @@ public final class Asin<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Asin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Asin<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Asin<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Asin", scope.makeOpName("Asin"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Asin<T>(opBuilder.build());
   }
@@ -73,7 +73,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 33cc22dd0b6..66a1b70af20 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes inverse hyperbolic sine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Asinh<T extends Tensor> extends RawOp 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.
@@ -53,9 +53,9 @@ public final class Asinh<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Asinh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Asinh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Asinh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Asinh", scope.makeOpName("Asinh"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Asinh<T>(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 0d46418dd5c..bdbb4229400 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the trignometric inverse tangent of x element-wise.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Atan<T extends Tensor> extends RawOp 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.
@@ -59,9 +59,9 @@ public final class Atan<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Atan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Atan<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Atan<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Atan", scope.makeOpName("Atan"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Atan<T>(opBuilder.build());
   }
@@ -73,7 +73,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 0a05b13d990..7cba9ee2011 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Atan2<T extends Tensor & TNumber> extends RawOp 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.
@@ -51,10 +50,10 @@ public final class Atan2<T extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Atan2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Atan2<T> create(Scope scope, Operand<T> y, Operand<T> x) {
+  public static <T extends TNumber> Atan2<T> create(Scope scope, Operand<T> y, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Atan2", scope.makeOpName("Atan2"));
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Atan2<T>(opBuilder.build());
   }
@@ -66,7 +65,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 aea16a1c015..57119b8129f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes inverse hyperbolic tangent of x element-wise.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Atanh<T extends Tensor> extends RawOp 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.
@@ -55,9 +55,9 @@ public final class Atanh<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Atanh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Atanh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Atanh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Atanh", scope.makeOpName("Atanh"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Atanh<T>(opBuilder.build());
   }
@@ -69,7 +69,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 267c801fe6b..fec91e77944 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class BesselI0e<T extends Tensor & TNumber> extends RawOp 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.
@@ -49,9 +48,9 @@ public final class BesselI0e<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of BesselI0e
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BesselI0e<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> BesselI0e<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("BesselI0e", scope.makeOpName("BesselI0e"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BesselI0e<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 ca7571067b0..8d27f3b7bd1 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class BesselI1e<T extends Tensor & TNumber> extends RawOp 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.
@@ -49,9 +48,9 @@ public final class BesselI1e<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of BesselI1e
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BesselI1e<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> BesselI1e<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("BesselI1e", scope.makeOpName("BesselI1e"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BesselI1e<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 597985dd639..490b04879cd 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -45,7 +44,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Betainc<T extends Tensor & TNumber> extends RawOp 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.
@@ -57,11 +56,11 @@ public final class Betainc<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Betainc
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Betainc<T> create(Scope scope, Operand<T> a, Operand<T> b, Operand<T> x) {
+  public static <T extends TNumber> Betainc<T> create(Scope scope, Operand<T> a, Operand<T> b, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Betainc", scope.makeOpName("Betainc"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Betainc<T>(opBuilder.build());
   }
@@ -73,7 +72,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 8946584d9e6..96a95c87c84 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -43,7 +42,7 @@
  * @param <T> data type for {@code bins()} output
  */
 @Operator(group = "math")
-public final class Bincount<T extends Tensor & TNumber> extends RawOp 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.
@@ -57,11 +56,11 @@ public final class Bincount<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Bincount
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Bincount<T> create(Scope scope, Operand<TInt32> arr, Operand<TInt32> size, Operand<T> weights) {
+  public static <T extends TNumber> Bincount<T> create(Scope scope, Operand<TInt32> arr, Operand<TInt32> size, Operand<T> weights) {
     OperationBuilder opBuilder = scope.env().opBuilder("Bincount", scope.makeOpName("Bincount"));
-    opBuilder.addInput(arr.asOutput());
-    opBuilder.addInput(size.asOutput());
-    opBuilder.addInput(weights.asOutput());
+    opBuilder.addInput(arr.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
+    opBuilder.addInput(weights.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Bincount<T>(opBuilder.build());
   }
@@ -75,7 +74,7 @@ public Output<T> bins() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return bins;
   }
   
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 1aa94156af4..37fd93a6fc1 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Ceil<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,9 +43,9 @@ public final class Ceil<T extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Ceil
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Ceil<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Ceil<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Ceil", scope.makeOpName("Ceil"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Ceil<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 8645138dc70..44b2c0d2370 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TUint8;
+import org.tensorflow.types.family.TType;
 
 /**
  * Compare values of `input` to `threshold` and pack resulting bits into a `uint8`.
@@ -65,10 +65,10 @@ public final class CompareAndBitpack extends RawOp implements Operand<TUint8> {
    * @return a new instance of CompareAndBitpack
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> CompareAndBitpack create(Scope scope, Operand<T> input, Operand<T> threshold) {
+  public static <T extends TType> CompareAndBitpack create(Scope scope, Operand<T> input, Operand<T> threshold) {
     OperationBuilder opBuilder = scope.env().opBuilder("CompareAndBitpack", scope.makeOpName("CompareAndBitpack"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(threshold.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(threshold.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new CompareAndBitpack(opBuilder.build());
   }
@@ -81,7 +81,7 @@ public Output<TUint8> output() {
   }
   
   @Override
-  public Output<TUint8> asOutput() {
+  public Output<TUint8> asOutput(Scope scope) {
     return output;
   }
   
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 3e0f1ef5a5a..d3a50e88bed 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the complex absolute value of a tensor.
@@ -41,7 +41,7 @@
  * @param <U> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class ComplexAbs<U extends Tensor & TNumber> extends RawOp 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.
@@ -52,9 +52,9 @@ public final class ComplexAbs<U extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of ComplexAbs
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> ComplexAbs<U> create(Scope scope, Operand<T> x, DataType<U> Tout) {
+  public static <U extends TNumber, T extends TType> ComplexAbs<U> create(Scope scope, Operand<T> x, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("ComplexAbs", scope.makeOpName("ComplexAbs"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tout", Tout);
     return new ComplexAbs<U>(opBuilder.build());
@@ -68,7 +68,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> ComplexAbs<U> creat
    * @return a new instance of ComplexAbs
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ComplexAbs<TFloat32> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> ComplexAbs<TFloat32> create(Scope scope, Operand<T> x) {
     return create(scope, x, TFloat32.DTYPE);
   }
   
@@ -79,7 +79,7 @@ public Output<U> y() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return y;
   }
   
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 68ea9c22be0..be16314d8a0 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the complex conjugate of a complex number.
@@ -47,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Conj<T extends Tensor> extends RawOp 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.
@@ -57,9 +57,9 @@ public final class Conj<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Conj
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Conj<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Conj<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conj", scope.makeOpName("Conj"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Conj<T>(opBuilder.build());
   }
@@ -71,7 +71,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 b3c193ac80f..2d8637b22aa 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes cos of x element-wise.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Cos<T extends Tensor> extends RawOp 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.
@@ -54,9 +54,9 @@ public final class Cos<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Cos
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Cos<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Cos<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cos", scope.makeOpName("Cos"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Cos<T>(opBuilder.build());
   }
@@ -68,7 +68,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 6da422436ac..ef2b9d1ba68 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes hyperbolic cosine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Cosh<T extends Tensor> extends RawOp 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.
@@ -53,9 +53,9 @@ public final class Cosh<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Cosh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Cosh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Cosh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cosh", scope.makeOpName("Cosh"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Cosh<T>(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 3e2e807bce0..4c5aeadb4d7 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Compute the cumulative product of the tensor `x` along `axis`.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "math")
-public final class Cumprod<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Cumprod<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Cumprod}
@@ -100,10 +100,10 @@ private Options() {
    * @return a new instance of Cumprod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Cumprod<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> Cumprod<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cumprod", scope.makeOpName("Cumprod"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -139,7 +139,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 18609d5d886..59ade631a4a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Compute the cumulative sum of the tensor `x` along `axis`.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "math")
-public final class Cumsum<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Cumsum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Cumsum}
@@ -100,10 +100,10 @@ private Options() {
    * @return a new instance of Cumsum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Cumsum<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> Cumsum<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Cumsum", scope.makeOpName("Cumsum"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -139,7 +139,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 bb5c1ebea04..42e74f8e083 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -51,7 +50,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class CumulativeLogsumexp<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class CumulativeLogsumexp<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.CumulativeLogsumexp}
@@ -92,10 +91,10 @@ private Options() {
    * @return a new instance of CumulativeLogsumexp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> CumulativeLogsumexp<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
+  public static <T extends TNumber, U extends TNumber> CumulativeLogsumexp<T> create(Scope scope, Operand<T> x, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CumulativeLogsumexp", scope.makeOpName("CumulativeLogsumexp"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -131,7 +130,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 d16d8e203c0..e14ae8c88d0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Digamma<T extends Tensor & TNumber> extends RawOp 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.
@@ -46,9 +45,9 @@ public final class Digamma<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Digamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Digamma<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Digamma<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Digamma", scope.makeOpName("Digamma"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Digamma<T>(opBuilder.build());
   }
@@ -60,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 c01625379d7..e54d21d723f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x / y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Div<T extends Tensor> extends RawOp 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.
@@ -47,10 +47,10 @@ public final class Div<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Div
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Div<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Div<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Div", scope.makeOpName("Div"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Div<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 ed606db6286..ae147962cb6 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if the denominator is zero.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class DivNoNan<T extends Tensor> extends RawOp 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.
@@ -48,10 +48,10 @@ public final class DivNoNan<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of DivNoNan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DivNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> DivNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("DivNoNan", scope.makeOpName("DivNoNan"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DivNoNan<T>(opBuilder.build());
   }
@@ -63,7 +63,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 1e94e267791..77fc951c423 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x == y) element-wise.
@@ -76,10 +76,10 @@ private Options() {
    * @return a new instance of Equal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Equal create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends TType> Equal create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Equal", scope.makeOpName("Equal"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -105,7 +105,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 9fa4d11e2e0..1cf51551137 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Erf<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,9 +43,9 @@ public final class Erf<T extends Tensor & TNumber> extends RawOp implements Oper
    * @return a new instance of Erf
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Erf<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Erf<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Erf", scope.makeOpName("Erf"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Erf<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 dcc0dd65650..e6e8930454d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Erfc<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,9 +43,9 @@ public final class Erfc<T extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Erfc
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Erfc<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Erfc<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Erfc", scope.makeOpName("Erfc"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Erfc<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 8542111fbff..e3997c7850a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes exponential of x element-wise.  \\(y = e^x\\).
@@ -59,7 +59,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Exp<T extends Tensor> extends RawOp 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.
@@ -69,9 +69,9 @@ public final class Exp<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Exp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Exp<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Exp<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Exp", scope.makeOpName("Exp"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Exp<T>(opBuilder.build());
   }
@@ -83,7 +83,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 00163735d6d..677c2ace1f6 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes `exp(x) - 1` element-wise.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Expm1<T extends Tensor> extends RawOp 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.
@@ -58,9 +58,9 @@ public final class Expm1<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Expm1
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Expm1<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Expm1<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Expm1", scope.makeOpName("Expm1"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Expm1<T>(opBuilder.build());
   }
@@ -72,7 +72,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 7c8f8af6c95..968e6b2ee98 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
@@ -53,7 +53,7 @@ public Output<TString> fact() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return fact;
   }
   
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 fd4573c21d7..eafeab0bc8c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Floor<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,9 +43,9 @@ public final class Floor<T extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Floor
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Floor<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Floor<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Floor", scope.makeOpName("Floor"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Floor<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 eafdb394715..caaf3f502c8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x // y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class FloorDiv<T extends Tensor> extends RawOp 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.
@@ -47,10 +47,10 @@ public final class FloorDiv<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of FloorDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> FloorDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> FloorDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("FloorDiv", scope.makeOpName("FloorDiv"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new FloorDiv<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 1d80323aa2a..c1eba02f8ba 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class FloorMod<T extends Tensor & TNumber> extends RawOp 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.
@@ -51,10 +50,10 @@ public final class FloorMod<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of FloorMod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FloorMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> FloorMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("FloorMod", scope.makeOpName("FloorMod"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new FloorMod<T>(opBuilder.build());
   }
@@ -66,7 +65,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 6a08ace5adf..8414333218d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -59,10 +58,10 @@ public final class Greater extends RawOp implements Operand<TBool> {
    * @return a new instance of Greater
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Greater create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> Greater create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Greater", scope.makeOpName("Greater"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Greater(opBuilder.build());
   }
@@ -74,7 +73,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 f1a48915994..180276c51ea 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -59,10 +58,10 @@ public final class GreaterEqual extends RawOp implements Operand<TBool> {
    * @return a new instance of GreaterEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> GreaterEqual create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> GreaterEqual create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("GreaterEqual", scope.makeOpName("GreaterEqual"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new GreaterEqual(opBuilder.build());
   }
@@ -74,7 +73,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 32e3f4d33a9..87533395fed 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -47,7 +46,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Igamma<T extends Tensor & TNumber> extends RawOp 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.
@@ -58,10 +57,10 @@ public final class Igamma<T extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of Igamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Igamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends TNumber> Igamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Igamma", scope.makeOpName("Igamma"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Igamma<T>(opBuilder.build());
   }
@@ -73,7 +72,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 db91047e686..a0251e5afe0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class IgammaGradA<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,10 +43,10 @@ public final class IgammaGradA<T extends Tensor & TNumber> extends RawOp impleme
    * @return a new instance of IgammaGradA
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> IgammaGradA<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends TNumber> IgammaGradA<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IgammaGradA", scope.makeOpName("IgammaGradA"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IgammaGradA<T>(opBuilder.build());
   }
@@ -59,7 +58,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 4a521b87b2f..8ab45b4858b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -47,7 +46,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Igammac<T extends Tensor & TNumber> extends RawOp 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.
@@ -58,10 +57,10 @@ public final class Igammac<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Igammac
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Igammac<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends TNumber> Igammac<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Igammac", scope.makeOpName("Igammac"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Igammac<T>(opBuilder.build());
   }
@@ -73,7 +72,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 eb3b746cbb7..12b6f2f89cf 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the imaginary part of a complex number.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Imag<U extends Tensor & TNumber> extends RawOp 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.
@@ -59,9 +59,9 @@ public final class Imag<U extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Imag
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Imag<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
+  public static <U extends TNumber, T extends TType> Imag<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Imag", scope.makeOpName("Imag"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tout", Tout);
     return new Imag<U>(opBuilder.build());
@@ -75,7 +75,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Imag<U> create(Scop
    * @return a new instance of Imag
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Imag<TFloat32> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Imag<TFloat32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TFloat32.DTYPE);
   }
   
@@ -86,7 +86,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 4befe1f36d6..878f969449f 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -50,7 +49,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class InvertPermutation<T extends Tensor & TNumber> extends RawOp 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.
@@ -60,9 +59,9 @@ public final class InvertPermutation<T extends Tensor & TNumber> extends RawOp i
    * @return a new instance of InvertPermutation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> InvertPermutation<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> InvertPermutation<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("InvertPermutation", scope.makeOpName("InvertPermutation"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new InvertPermutation<T>(opBuilder.build());
   }
@@ -75,7 +74,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 abd8d0af84c..9d7198a36f0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,9 +53,9 @@ public final class IsFinite extends RawOp implements Operand<TBool> {
    * @return a new instance of IsFinite
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> IsFinite create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> IsFinite create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsFinite", scope.makeOpName("IsFinite"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IsFinite(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<TBool> y() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return y;
   }
   
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 3e442b86e84..9a7d8b43bef 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,9 +53,9 @@ public final class IsInf extends RawOp implements Operand<TBool> {
    * @return a new instance of IsInf
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> IsInf create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> IsInf create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsInf", scope.makeOpName("IsInf"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IsInf(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<TBool> y() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return y;
   }
   
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 17e27eef753..c33accf07a7 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,9 +53,9 @@ public final class IsNan extends RawOp implements Operand<TBool> {
    * @return a new instance of IsNan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> IsNan create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> IsNan create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("IsNan", scope.makeOpName("IsNan"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new IsNan(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<TBool> y() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return y;
   }
   
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 9e9f470f7a1..493b51a416b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -59,10 +58,10 @@ public final class Less extends RawOp implements Operand<TBool> {
    * @return a new instance of Less
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Less create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> Less create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Less", scope.makeOpName("Less"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Less(opBuilder.build());
   }
@@ -74,7 +73,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 29e94952061..aa714c6bcf9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -59,10 +58,10 @@ public final class LessEqual extends RawOp implements Operand<TBool> {
    * @return a new instance of LessEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LessEqual create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> LessEqual create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("LessEqual", scope.makeOpName("LessEqual"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LessEqual(opBuilder.build());
   }
@@ -74,7 +73,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 a2fbbcbea08..fb0399cad70 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -44,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Lgamma<T extends Tensor & TNumber> extends RawOp 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.
@@ -54,9 +53,9 @@ public final class Lgamma<T extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of Lgamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Lgamma<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Lgamma<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Lgamma", scope.makeOpName("Lgamma"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Lgamma<T>(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 97206730d28..aa382cdafbc 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes natural logarithm of x element-wise.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Log<T extends Tensor> extends RawOp 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.
@@ -52,9 +52,9 @@ public final class Log<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Log
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Log<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Log<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Log", scope.makeOpName("Log"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Log<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 8b53d6f7121..fe535170ced 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes natural logarithm of (1 + x) element-wise.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Log1p<T extends Tensor> extends RawOp 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.
@@ -52,9 +52,9 @@ public final class Log1p<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Log1p
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Log1p<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Log1p<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Log1p", scope.makeOpName("Log1p"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Log1p<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 410cd28dc9d..d527c0bef36 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
@@ -47,8 +47,8 @@ public final class LogicalAnd extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static LogicalAnd create(Scope scope, Operand<TBool> x, Operand<TBool> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogicalAnd", scope.makeOpName("LogicalAnd"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LogicalAnd(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 643af8caa45..664ab52ce71 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
@@ -43,7 +43,7 @@ public final class LogicalNot extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static LogicalNot create(Scope scope, Operand<TBool> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogicalNot", scope.makeOpName("LogicalNot"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LogicalNot(opBuilder.build());
   }
@@ -56,7 +56,7 @@ public Output<TBool> y() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return y;
   }
   
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 a9f33397ae1..e542b9cdbb3 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
@@ -47,8 +47,8 @@ public final class LogicalOr extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static LogicalOr create(Scope scope, Operand<TBool> x, Operand<TBool> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogicalOr", scope.makeOpName("LogicalOr"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LogicalOr(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 eec3edcc74f..d8343eeef55 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Maximum<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,10 +47,10 @@ public final class Maximum<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Maximum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Maximum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> Maximum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Maximum", scope.makeOpName("Maximum"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Maximum<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 21d824df360..90af0e38cb0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the mean of elements across dimensions of a tensor.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Mean<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Mean<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.math.Mean}
@@ -71,10 +71,10 @@ private Options() {
    * @return a new instance of Mean
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Mean<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
+  public static <T extends TType, U extends TNumber> Mean<T> create(Scope scope, Operand<T> input, Operand<U> axis, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Mean", scope.makeOpName("Mean"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(axis.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(axis.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 0f07335a85c..e62f0d76715 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Minimum<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,10 +47,10 @@ public final class Minimum<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Minimum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Minimum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> Minimum<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Minimum", scope.makeOpName("Minimum"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Minimum<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 f6df61b1346..9510c00a07e 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Mod<T extends Tensor & TNumber> extends RawOp 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.
@@ -51,10 +50,10 @@ public final class Mod<T extends Tensor & TNumber> extends RawOp implements Oper
    * @return a new instance of Mod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Mod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> Mod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Mod", scope.makeOpName("Mod"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Mod<T>(opBuilder.build());
   }
@@ -66,7 +65,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 8b35d5fe0c8..eda0a87907c 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x * y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Mul<T extends Tensor> extends RawOp 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.
@@ -47,10 +47,10 @@ public final class Mul<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Mul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Mul<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Mul<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Mul", scope.makeOpName("Mul"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Mul<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 2178e0c6b3f..04b2f06d0fd 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x * y element-wise. Returns zero if y is zero, even if x if infinite or NaN.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class MulNoNan<T extends Tensor> extends RawOp 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.
@@ -47,10 +47,10 @@ public final class MulNoNan<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of MulNoNan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MulNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> MulNoNan<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("MulNoNan", scope.makeOpName("MulNoNan"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MulNoNan<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 39dec8488c0..4fb1087097a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Ndtri<T extends Tensor & TNumber> extends RawOp 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.
@@ -42,9 +41,9 @@ public final class Ndtri<T extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Ndtri
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Ndtri<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Ndtri<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Ndtri", scope.makeOpName("Ndtri"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Ndtri<T>(opBuilder.build());
   }
@@ -56,7 +55,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 5bfb96281c1..6e0f2bfc302 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes numerical negative value element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Neg<T extends Tensor> extends RawOp 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.
@@ -45,9 +45,9 @@ public final class Neg<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Neg
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Neg<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Neg<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Neg", scope.makeOpName("Neg"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Neg<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 fa30f0a5692..a8e3d0c1eb8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class NextAfter<T extends Tensor & TNumber> extends RawOp 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.
@@ -53,10 +52,10 @@ public final class NextAfter<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of NextAfter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> NextAfter<T> create(Scope scope, Operand<T> x1, Operand<T> x2) {
+  public static <T extends TNumber> NextAfter<T> create(Scope scope, Operand<T> x1, Operand<T> x2) {
     OperationBuilder opBuilder = scope.env().opBuilder("NextAfter", scope.makeOpName("NextAfter"));
-    opBuilder.addInput(x1.asOutput());
-    opBuilder.addInput(x2.asOutput());
+    opBuilder.addInput(x1.asOutput(scope));
+    opBuilder.addInput(x2.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new NextAfter<T>(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5592d5ba668..a6e7143bd8f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the truth value of (x != y) element-wise.
@@ -66,10 +66,10 @@ private Options() {
    * @return a new instance of NotEqual
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> NotEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends TType> NotEqual create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("NotEqual", scope.makeOpName("NotEqual"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -95,7 +95,7 @@ public Output<TBool> z() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return z;
   }
   
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 0133142551c..98aae4656fe 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -41,7 +40,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Polygamma<T extends Tensor & TNumber> extends RawOp 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.
@@ -52,10 +51,10 @@ public final class Polygamma<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of Polygamma
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Polygamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
+  public static <T extends TNumber> Polygamma<T> create(Scope scope, Operand<T> a, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Polygamma", scope.makeOpName("Polygamma"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Polygamma<T>(opBuilder.build());
   }
@@ -67,7 +66,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 f1c9fc1811e..33422655dab 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -50,9 +49,9 @@ public final class PopulationCount extends RawOp implements Operand<TUint8> {
    * @return a new instance of PopulationCount
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> PopulationCount create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> PopulationCount create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("PopulationCount", scope.makeOpName("PopulationCount"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new PopulationCount(opBuilder.build());
   }
@@ -64,7 +63,7 @@ public Output<TUint8> y() {
   }
   
   @Override
-  public Output<TUint8> asOutput() {
+  public Output<TUint8> asOutput(Scope scope) {
     return y;
   }
   
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 1b10d6d3c15..0400c975445 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the power of one value to another.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Pow<T extends Tensor> extends RawOp 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.
@@ -53,10 +53,10 @@ public final class Pow<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Pow
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Pow<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Pow<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Pow", scope.makeOpName("Pow"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Pow<T>(opBuilder.build());
   }
@@ -68,7 +68,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 c19f5e28dd8..67de8d4c40d 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x + y element-wise, working on quantized buffers.
@@ -35,7 +35,7 @@
  * @param <V> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class QuantizedAdd<V extends Tensor> extends RawOp {
+public final class QuantizedAdd<V extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedAdd operation.
@@ -51,14 +51,14 @@ public final class QuantizedAdd<V extends Tensor> extends RawOp {
    * @return a new instance of QuantizedAdd
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedAdd<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedAdd<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedAdd", scope.makeOpName("QuantizedAdd"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(minX.asOutput());
-    opBuilder.addInput(maxX.asOutput());
-    opBuilder.addInput(minY.asOutput());
-    opBuilder.addInput(maxY.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(minX.asOutput(scope));
+    opBuilder.addInput(maxX.asOutput(scope));
+    opBuilder.addInput(minY.asOutput(scope));
+    opBuilder.addInput(maxY.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     return new QuantizedAdd<V>(opBuilder.build());
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 773336d3966..54941712be3 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x * y element-wise, working on quantized buffers.
@@ -35,7 +35,7 @@
  * @param <V> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class QuantizedMul<V extends Tensor> extends RawOp {
+public final class QuantizedMul<V extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedMul operation.
@@ -51,14 +51,14 @@ public final class QuantizedMul<V extends Tensor> extends RawOp {
    * @return a new instance of QuantizedMul
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedMul<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedMul<V> create(Scope scope, Operand<T> x, Operand<U> y, Operand<TFloat32> minX, Operand<TFloat32> maxX, Operand<TFloat32> minY, Operand<TFloat32> maxY, DataType<V> Toutput) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMul", scope.makeOpName("QuantizedMul"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(minX.asOutput());
-    opBuilder.addInput(maxX.asOutput());
-    opBuilder.addInput(minY.asOutput());
-    opBuilder.addInput(maxY.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(minX.asOutput(scope));
+    opBuilder.addInput(maxX.asOutput(scope));
+    opBuilder.addInput(minY.asOutput(scope));
+    opBuilder.addInput(maxY.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     return new QuantizedMul<V>(opBuilder.build());
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 3d8e66416a1..76afa38392a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the real part of a complex number.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class Real<U extends Tensor & TNumber> extends RawOp 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.
@@ -59,9 +59,9 @@ public final class Real<U extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Real
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Real<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
+  public static <U extends TNumber, T extends TType> Real<U> create(Scope scope, Operand<T> input, DataType<U> Tout) {
     OperationBuilder opBuilder = scope.env().opBuilder("Real", scope.makeOpName("Real"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tout", Tout);
     return new Real<U>(opBuilder.build());
@@ -75,7 +75,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Real<U> create(Scop
    * @return a new instance of Real
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Real<TFloat32> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Real<TFloat32> create(Scope scope, Operand<T> input) {
     return create(scope, input, TFloat32.DTYPE);
   }
   
@@ -86,7 +86,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 9ef6de048b6..6b893498a05 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x / y element-wise for real types.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class RealDiv<T extends Tensor> extends RawOp 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.
@@ -49,10 +49,10 @@ public final class RealDiv<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of RealDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RealDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> RealDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("RealDiv", scope.makeOpName("RealDiv"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RealDiv<T>(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 60ba376974e..939d864d9e0 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the reciprocal of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Reciprocal<T extends Tensor> extends RawOp 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.
@@ -45,9 +45,9 @@ public final class Reciprocal<T extends Tensor> extends RawOp implements Operand
    * @return a new instance of Reciprocal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Reciprocal<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Reciprocal<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Reciprocal", scope.makeOpName("Reciprocal"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Reciprocal<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 9fdf8dba280..b57429e84f1 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the inverse of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class ReciprocalGrad<T extends Tensor> extends RawOp 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.
@@ -46,10 +46,10 @@ public final class ReciprocalGrad<T extends Tensor> extends RawOp implements Ope
    * @return a new instance of ReciprocalGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ReciprocalGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends TType> ReciprocalGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReciprocalGrad", scope.makeOpName("ReciprocalGrad"));
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(dy.asOutput());
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(dy.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReciprocalGrad<T>(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 ff393a3fc3b..b2d59b24c04 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes requantization range per channel.
@@ -45,11 +45,11 @@ public final class RequantizationRangePerChannel extends RawOp {
    * @return a new instance of RequantizationRangePerChannel
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RequantizationRangePerChannel create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Float clipValueMax) {
+  public static <T extends TType> RequantizationRangePerChannel create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Float clipValueMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("RequantizationRangePerChannel", scope.makeOpName("RequantizationRangePerChannel"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputMin.asOutput());
-    opBuilder.addInput(inputMax.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputMin.asOutput(scope));
+    opBuilder.addInput(inputMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("clip_value_max", clipValueMax);
     return new RequantizationRangePerChannel(opBuilder.build());
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 430229fde64..18bbeb1e527 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Requantizes input with min and max values known per channel.
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class RequantizePerChannel<U extends Tensor> extends RawOp {
+public final class RequantizePerChannel<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RequantizePerChannel operation.
@@ -49,13 +49,13 @@ public final class RequantizePerChannel<U extends Tensor> extends RawOp {
    * @return a new instance of RequantizePerChannel
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> RequantizePerChannel<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
+  public static <U extends TType, T extends TType> RequantizePerChannel<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("RequantizePerChannel", scope.makeOpName("RequantizePerChannel"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputMin.asOutput());
-    opBuilder.addInput(inputMax.asOutput());
-    opBuilder.addInput(requestedOutputMin.asOutput());
-    opBuilder.addInput(requestedOutputMax.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputMin.asOutput(scope));
+    opBuilder.addInput(inputMax.asOutput(scope));
+    opBuilder.addInput(requestedOutputMin.asOutput(scope));
+    opBuilder.addInput(requestedOutputMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new RequantizePerChannel<U>(opBuilder.build());
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 2b8b4edbf21..a28b2a73f27 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -44,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Rint<T extends Tensor & TNumber> extends RawOp 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.
@@ -54,9 +53,9 @@ public final class Rint<T extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Rint
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Rint<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Rint<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Rint", scope.makeOpName("Rint"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Rint<T>(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 ecc60b82461..0465505efed 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Rounds the values of a tensor to the nearest integer, element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Round<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class Round<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Round
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Round<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Round<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Round", scope.makeOpName("Round"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Round<T>(opBuilder.build());
   }
@@ -60,7 +60,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 2d91d211f82..6d2ac552283 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes reciprocal of square root of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Rsqrt<T extends Tensor> extends RawOp 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.
@@ -45,9 +45,9 @@ public final class Rsqrt<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Rsqrt
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Rsqrt<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Rsqrt<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Rsqrt", scope.makeOpName("Rsqrt"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Rsqrt<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 b3ced8e9431..652677c852f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the rsqrt of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class RsqrtGrad<T extends Tensor> extends RawOp 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.
@@ -46,10 +46,10 @@ public final class RsqrtGrad<T extends Tensor> extends RawOp implements Operand<
    * @return a new instance of RsqrtGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RsqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends TType> RsqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("RsqrtGrad", scope.makeOpName("RsqrtGrad"));
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(dy.asOutput());
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(dy.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RsqrtGrad<T>(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 4ca3e332b7f..335047407e9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -57,7 +56,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMax<T extends Tensor & TNumber> extends RawOp 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.
@@ -69,10 +68,10 @@ public final class SegmentMax<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of SegmentMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends TNumber, U extends TNumber> SegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentMax", scope.makeOpName("SegmentMax"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SegmentMax<T>(opBuilder.build());
   }
@@ -86,7 +85,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 f46867f05f8..404119f58c1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the mean along segments of a tensor.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMean<T extends Tensor> extends RawOp 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.
@@ -70,10 +70,10 @@ public final class SegmentMean<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of SegmentMean
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends TType, U extends TNumber> SegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentMean", scope.makeOpName("SegmentMean"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SegmentMean<T>(opBuilder.build());
   }
@@ -87,7 +87,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 eb2470fc01c..cbb0c9e7f06 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -57,7 +56,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentMin<T extends Tensor & TNumber> extends RawOp 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.
@@ -69,10 +68,10 @@ public final class SegmentMin<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of SegmentMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends TNumber, U extends TNumber> SegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentMin", scope.makeOpName("SegmentMin"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SegmentMin<T>(opBuilder.build());
   }
@@ -86,7 +85,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 44d2d9abd51..d0b762b67ac 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product along segments of a tensor.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentProd<T extends Tensor> extends RawOp 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.
@@ -69,10 +69,10 @@ public final class SegmentProd<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of SegmentProd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends TType, U extends TNumber> SegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentProd", scope.makeOpName("SegmentProd"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SegmentProd<T>(opBuilder.build());
   }
@@ -86,7 +86,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 39bb1760032..8105944d561 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along segments of a tensor.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class SegmentSum<T extends Tensor> extends RawOp 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.
@@ -69,10 +69,10 @@ public final class SegmentSum<T extends Tensor> extends RawOp implements Operand
    * @return a new instance of SegmentSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
+  public static <T extends TType, U extends TNumber> SegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SegmentSum", scope.makeOpName("SegmentSum"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SegmentSum<T>(opBuilder.build());
   }
@@ -86,7 +86,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 37494783825..bbadefd6ebe 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes sigmoid of `x` element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sigmoid<T extends Tensor> extends RawOp 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.
@@ -45,9 +45,9 @@ public final class Sigmoid<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Sigmoid
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sigmoid<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Sigmoid<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sigmoid", scope.makeOpName("Sigmoid"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sigmoid<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 bd84abe5a06..ef02016ff69 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient of the sigmoid of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class SigmoidGrad<T extends Tensor> extends RawOp 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.
@@ -46,10 +46,10 @@ public final class SigmoidGrad<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of SigmoidGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SigmoidGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends TType> SigmoidGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("SigmoidGrad", scope.makeOpName("SigmoidGrad"));
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(dy.asOutput());
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(dy.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SigmoidGrad<T>(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 153ce0c1e35..1ad5ec74846 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns an element-wise indication of the sign of a number.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sign<T extends Tensor> extends RawOp 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.
@@ -51,9 +51,9 @@ public final class Sign<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Sign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sign<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Sign<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sign", scope.makeOpName("Sign"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sign<T>(opBuilder.build());
   }
@@ -65,7 +65,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 f76834c0ab9..2d2fd99dae2 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes sine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sin<T extends Tensor> extends RawOp 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.
@@ -53,9 +53,9 @@ public final class Sin<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Sin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sin<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Sin<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sin", scope.makeOpName("Sin"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sin<T>(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 e83292babad..57d976703da 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes hyperbolic sine of x element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sinh<T extends Tensor> extends RawOp 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.
@@ -53,9 +53,9 @@ public final class Sinh<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Sinh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sinh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Sinh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sinh", scope.makeOpName("Sinh"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sinh<T>(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java
index 7b1b28e8ad6..e6fdfa5ff99 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/SobolSample.java
@@ -22,7 +22,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * 
  * @param <T> data type for {@code samples()} output
  */
-public final class SobolSample<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class SobolSample<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new SobolSample operation.
@@ -54,11 +53,11 @@ public final class SobolSample<T extends Tensor & TNumber> extends RawOp impleme
    * @return a new instance of SobolSample
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SobolSample<T> create(Scope scope, Operand<TInt32> dim, Operand<TInt32> numResults, Operand<TInt32> skip, DataType<T> dtype) {
+  public static <T extends TNumber> SobolSample<T> create(Scope scope, Operand<TInt32> dim, Operand<TInt32> numResults, Operand<TInt32> skip, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("SobolSample", scope.makeOpName("SobolSample"));
-    opBuilder.addInput(dim.asOutput());
-    opBuilder.addInput(numResults.asOutput());
-    opBuilder.addInput(skip.asOutput());
+    opBuilder.addInput(dim.asOutput(scope));
+    opBuilder.addInput(numResults.asOutput(scope));
+    opBuilder.addInput(skip.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new SobolSample<T>(opBuilder.build());
@@ -88,7 +87,7 @@ public Output<T> samples() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return samples;
   }
   
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 4e41165d496..925e4e7d1df 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "math")
-public final class Softplus<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,9 +43,9 @@ public final class Softplus<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Softplus
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Softplus<T> create(Scope scope, Operand<T> features) {
+  public static <T extends TNumber> Softplus<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Softplus", scope.makeOpName("Softplus"));
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Softplus<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> activations() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return activations;
   }
   
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 06be5e484aa..c335a30ef8b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SoftplusGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,10 +43,10 @@ public final class SoftplusGrad<T extends Tensor & TNumber> extends RawOp implem
    * @return a new instance of SoftplusGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SoftplusGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends TNumber> SoftplusGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("SoftplusGrad", scope.makeOpName("SoftplusGrad"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SoftplusGrad<T>(opBuilder.build());
   }
@@ -60,7 +59,7 @@ public Output<T> backprops() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return backprops;
   }
   
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 aaf89d7e457..85d9c840601 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes square root of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Sqrt<T extends Tensor> extends RawOp 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.
@@ -45,9 +45,9 @@ public final class Sqrt<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Sqrt
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sqrt<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Sqrt<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sqrt", scope.makeOpName("Sqrt"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sqrt<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 eb5bd051a28..42209ad8a06 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the sqrt of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class SqrtGrad<T extends Tensor> extends RawOp 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.
@@ -46,10 +46,10 @@ public final class SqrtGrad<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of SqrtGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends TType> SqrtGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("SqrtGrad", scope.makeOpName("SqrtGrad"));
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(dy.asOutput());
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(dy.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SqrtGrad<T>(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 a8c3ed5312f..9d2ecb8cea2 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes square of x element-wise.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Square<T extends Tensor> extends RawOp 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.
@@ -45,9 +45,9 @@ public final class Square<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Square
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Square<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Square<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Square", scope.makeOpName("Square"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Square<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 7c9bc1ff285..0c84f22b7a8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns (x - y)(x - y) element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class SquaredDifference<T extends Tensor> extends RawOp 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.
@@ -47,10 +47,10 @@ public final class SquaredDifference<T extends Tensor> extends RawOp implements
    * @return a new instance of SquaredDifference
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SquaredDifference<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> SquaredDifference<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("SquaredDifference", scope.makeOpName("SquaredDifference"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SquaredDifference<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 54cc73e80c3..eb4cbda526d 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x - y element-wise.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Sub<T extends Tensor> extends RawOp 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.
@@ -47,10 +47,10 @@ public final class Sub<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Sub
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sub<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Sub<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Sub", scope.makeOpName("Sub"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sub<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 168c294dfb4..954d26fd435 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes tan of x element-wise.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Tan<T extends Tensor> extends RawOp 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.
@@ -54,9 +54,9 @@ public final class Tan<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Tan
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Tan<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Tan<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Tan", scope.makeOpName("Tan"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Tan<T>(opBuilder.build());
   }
@@ -68,7 +68,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 d9005cbb7dd..fe85a5d2062 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes hyperbolic tangent of `x` element-wise.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class Tanh<T extends Tensor> extends RawOp 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.
@@ -53,9 +53,9 @@ public final class Tanh<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Tanh
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Tanh<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TType> Tanh<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Tanh", scope.makeOpName("Tanh"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Tanh<T>(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 4f7ab7a3cbb..81a0c3d16c8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the tanh of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class TanhGrad<T extends Tensor> extends RawOp 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.
@@ -46,10 +46,10 @@ public final class TanhGrad<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of TanhGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TanhGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends TType> TanhGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("TanhGrad", scope.makeOpName("TanhGrad"));
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(dy.asOutput());
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(dy.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TanhGrad<T>(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 15e6ce321b7..388e37d1935 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns x / y element-wise for integer types.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class TruncateDiv<T extends Tensor> extends RawOp 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.
@@ -52,10 +52,10 @@ public final class TruncateDiv<T extends Tensor> extends RawOp implements Operan
    * @return a new instance of TruncateDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TruncateDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> TruncateDiv<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("TruncateDiv", scope.makeOpName("TruncateDiv"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TruncateDiv<T>(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 60cc6819a6b..8c42ea8587c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class TruncateMod<T extends Tensor & TNumber> extends RawOp 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.
@@ -51,10 +50,10 @@ public final class TruncateMod<T extends Tensor & TNumber> extends RawOp impleme
    * @return a new instance of TruncateMod
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> TruncateMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TNumber> TruncateMod<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("TruncateMod", scope.makeOpName("TruncateMod"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TruncateMod<T>(opBuilder.build());
   }
@@ -66,7 +65,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 96bb629837b..e81442b33a3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -65,7 +64,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentMax<T extends Tensor & TNumber> extends RawOp 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.
@@ -77,11 +76,11 @@ public final class UnsortedSegmentMax<T extends Tensor & TNumber> extends RawOp
    * @return a new instance of UnsortedSegmentMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMax<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentMax", scope.makeOpName("UnsortedSegmentMax"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new UnsortedSegmentMax<T>(opBuilder.build());
   }
@@ -96,7 +95,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a866fff93ed..187ce9dcb03 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -59,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentMin<T extends Tensor & TNumber> extends RawOp 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.
@@ -71,11 +70,11 @@ public final class UnsortedSegmentMin<T extends Tensor & TNumber> extends RawOp
    * @return a new instance of UnsortedSegmentMin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> UnsortedSegmentMin<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentMin", scope.makeOpName("UnsortedSegmentMin"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new UnsortedSegmentMin<T>(opBuilder.build());
   }
@@ -90,7 +89,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 030d3083fef..6a7b66ffb70 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the product along segments of a tensor.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentProd<T extends Tensor> extends RawOp 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.
@@ -70,11 +70,11 @@ public final class UnsortedSegmentProd<T extends Tensor> extends RawOp implement
    * @return a new instance of UnsortedSegmentProd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentProd<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentProd", scope.makeOpName("UnsortedSegmentProd"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new UnsortedSegmentProd<T>(opBuilder.build());
   }
@@ -89,7 +89,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 15880b264b7..cfe4c43cd90 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum along segments of a tensor.
@@ -61,7 +61,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "math")
-public final class UnsortedSegmentSum<T extends Tensor> extends RawOp 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.
@@ -73,11 +73,11 @@ public final class UnsortedSegmentSum<T extends Tensor> extends RawOp implements
    * @return a new instance of UnsortedSegmentSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber, V extends Tensor & TNumber> UnsortedSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
+  public static <T extends TType, U extends TNumber, V extends TNumber> UnsortedSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentSum", scope.makeOpName("UnsortedSegmentSum"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new UnsortedSegmentSum<T>(opBuilder.build());
   }
@@ -92,7 +92,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 364ecb2931b..33a5c6d0786 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if x == 0, and x / y otherwise, elementwise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xdivy<T extends Tensor> extends RawOp 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.
@@ -44,10 +44,10 @@ public final class Xdivy<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Xdivy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Xdivy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Xdivy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Xdivy", scope.makeOpName("Xdivy"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Xdivy<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java
index 180d995ecc4..e6ef2362c08 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/Xlog1py.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if x == 0, and x * log1p(y) otherwise, elementwise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xlog1py<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Xlog1py<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Xlog1py operation.
@@ -44,10 +44,10 @@ public final class Xlog1py<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Xlog1py
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Xlog1py<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Xlog1py<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Xlog1py", scope.makeOpName("Xlog1py"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Xlog1py<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 8aa86bbecd2..51cca9233f8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns 0 if x == 0, and x * log(y) otherwise, elementwise.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Xlogy<T extends Tensor> extends RawOp 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.
@@ -44,10 +44,10 @@ public final class Xlogy<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Xlogy
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Xlogy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
+  public static <T extends TType> Xlogy<T> create(Scope scope, Operand<T> x, Operand<T> y) {
     OperationBuilder opBuilder = scope.env().opBuilder("Xlogy", scope.makeOpName("Xlogy"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Xlogy<T>(opBuilder.build());
   }
@@ -59,7 +59,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 3e6998f3594..69bdc33bc9a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code z()} output
  */
 @Operator(group = "math")
-public final class Zeta<T extends Tensor & TNumber> extends RawOp 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.
@@ -49,10 +48,10 @@ public final class Zeta<T extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Zeta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Zeta<T> create(Scope scope, Operand<T> x, Operand<T> q) {
+  public static <T extends TNumber> Zeta<T> create(Scope scope, Operand<T> x, Operand<T> q) {
     OperationBuilder opBuilder = scope.env().opBuilder("Zeta", scope.makeOpName("Zeta"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(q.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(q.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Zeta<T>(opBuilder.build());
   }
@@ -64,7 +63,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 64b1b796213..13f0a2555f5 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -32,7 +31,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "math")
-public final class erfinv<T extends Tensor & TNumber> extends RawOp 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.
@@ -42,9 +41,9 @@ public final class erfinv<T extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of erfinv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> erfinv<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> erfinv<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Erfinv", scope.makeOpName("erfinv"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new erfinv<T>(opBuilder.build());
   }
@@ -56,7 +55,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java
index de63db71cfa..14ca4b1a238 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Dawsn.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -31,7 +30,7 @@
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class Dawsn<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Dawsn<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dawsn operation.
@@ -41,9 +40,9 @@ public final class Dawsn<T extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Dawsn
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Dawsn<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Dawsn<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dawsn", scope.makeOpName("Dawsn"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Dawsn<T>(opBuilder.build());
   }
@@ -55,7 +54,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java
index 1a66105c075..75b82d5393e 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Expint.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -31,7 +30,7 @@
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class Expint<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Expint<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Expint operation.
@@ -41,9 +40,9 @@ public final class Expint<T extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of Expint
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Expint<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Expint<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Expint", scope.makeOpName("Expint"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Expint<T>(opBuilder.build());
   }
@@ -55,7 +54,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java
index 22e89de3647..a3c01b3f907 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelCos.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -31,7 +30,7 @@
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class FresnelCos<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class FresnelCos<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FresnelCos operation.
@@ -41,9 +40,9 @@ public final class FresnelCos<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of FresnelCos
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FresnelCos<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> FresnelCos<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("FresnelCos", scope.makeOpName("FresnelCos"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new FresnelCos<T>(opBuilder.build());
   }
@@ -55,7 +54,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java
index 6197798a236..ad9b92c4bd0 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/FresnelSin.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -31,7 +30,7 @@
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class FresnelSin<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class FresnelSin<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new FresnelSin operation.
@@ -41,9 +40,9 @@ public final class FresnelSin<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of FresnelSin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FresnelSin<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> FresnelSin<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("FresnelSin", scope.makeOpName("FresnelSin"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new FresnelSin<T>(opBuilder.build());
   }
@@ -55,7 +54,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java
index f9b1827496f..db880ec0346 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/math/special/Spence.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -31,7 +30,7 @@
 /**
  * @param <T> data type for {@code y()} output
  */
-public final class Spence<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Spence<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Spence operation.
@@ -41,9 +40,9 @@ public final class Spence<T extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of Spence
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Spence<T> create(Scope scope, Operand<T> x) {
+  public static <T extends TNumber> Spence<T> create(Scope scope, Operand<T> x) {
     OperationBuilder opBuilder = scope.env().opBuilder("Spence", scope.makeOpName("Spence"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Spence<T>(opBuilder.build());
   }
@@ -55,7 +54,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 34609fc7dd2..d3ecec8e3e9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class AvgPool<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool}
@@ -75,9 +74,9 @@ private Options() {
    * @return a new instance of AvgPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AvgPool<T> create(Scope scope, Operand<T> value, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> AvgPool<T> create(Scope scope, Operand<T> value, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPool", scope.makeOpName("AvgPool"));
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -119,7 +118,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 56137eae22f..234c2f6f0fb 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool3d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class AvgPool3d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool3d}
@@ -74,9 +73,9 @@ private Options() {
    * @return a new instance of AvgPool3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AvgPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> AvgPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPool3D", scope.makeOpName("AvgPool3d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -118,7 +117,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a6c279225d4..2c3c2b086f9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class AvgPool3dGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class AvgPool3dGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPool3dGrad}
@@ -76,10 +75,10 @@ private Options() {
    * @return a new instance of AvgPool3dGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AvgPool3dGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> AvgPool3dGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPool3DGrad", scope.makeOpName("AvgPool3dGrad"));
-    opBuilder.addInput(origInputShape.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(origInputShape.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -121,7 +120,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c893b817da2..a358705c60d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AvgPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class AvgPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.AvgPoolGrad}
@@ -74,10 +73,10 @@ private Options() {
    * @return a new instance of AvgPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> AvgPoolGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> AvgPoolGrad<T> create(Scope scope, Operand<TInt32> origInputShape, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AvgPoolGrad", scope.makeOpName("AvgPoolGrad"));
-    opBuilder.addInput(origInputShape.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(origInputShape.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -119,7 +118,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 6ecc5a694a6..00e386428aa 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Batch normalization.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code result()} output
  */
 @Operator(group = "nn")
-public final class BatchNormWithGlobalNormalization<T extends Tensor> extends RawOp 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.
@@ -59,13 +59,13 @@ public final class BatchNormWithGlobalNormalization<T extends Tensor> extends Ra
    * @return a new instance of BatchNormWithGlobalNormalization
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchNormWithGlobalNormalization<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> beta, Operand<T> gamma, Float varianceEpsilon, Boolean scaleAfterNormalization) {
+  public static <T extends TType> BatchNormWithGlobalNormalization<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> beta, Operand<T> gamma, Float varianceEpsilon, Boolean scaleAfterNormalization) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchNormWithGlobalNormalization", scope.makeOpName("BatchNormWithGlobalNormalization"));
-    opBuilder.addInput(t.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(beta.asOutput());
-    opBuilder.addInput(gamma.asOutput());
+    opBuilder.addInput(t.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(beta.asOutput(scope));
+    opBuilder.addInput(gamma.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("variance_epsilon", varianceEpsilon);
     opBuilder.setAttr("scale_after_normalization", scaleAfterNormalization);
@@ -79,7 +79,7 @@ public Output<T> result() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return result;
   }
   
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 211c4d8c7a4..9b77a10fac2 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gradients for batch normalization.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code dx()} output
  */
 @Operator(group = "nn")
-public final class BatchNormWithGlobalNormalizationGrad<T extends Tensor> extends RawOp {
+public final class BatchNormWithGlobalNormalizationGrad<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BatchNormWithGlobalNormalizationGrad operation.
@@ -58,13 +58,13 @@ public final class BatchNormWithGlobalNormalizationGrad<T extends Tensor> extend
    * @return a new instance of BatchNormWithGlobalNormalizationGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchNormWithGlobalNormalizationGrad<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> gamma, Operand<T> backprop, Float varianceEpsilon, Boolean scaleAfterNormalization) {
+  public static <T extends TType> BatchNormWithGlobalNormalizationGrad<T> create(Scope scope, Operand<T> t, Operand<T> m, Operand<T> v, Operand<T> gamma, Operand<T> backprop, Float varianceEpsilon, Boolean scaleAfterNormalization) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchNormWithGlobalNormalizationGrad", scope.makeOpName("BatchNormWithGlobalNormalizationGrad"));
-    opBuilder.addInput(t.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(gamma.asOutput());
-    opBuilder.addInput(backprop.asOutput());
+    opBuilder.addInput(t.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(gamma.asOutput(scope));
+    opBuilder.addInput(backprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("variance_epsilon", varianceEpsilon);
     opBuilder.setAttr("scale_after_normalization", scaleAfterNormalization);
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 9a4fa545bd4..10c22b99d55 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds `bias` to `value`.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class BiasAdd<T extends Tensor> extends RawOp implements Operand<T> {
+public final class BiasAdd<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BiasAdd}
@@ -73,10 +73,10 @@ private Options() {
    * @return a new instance of BiasAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BiasAdd<T> create(Scope scope, Operand<T> value, Operand<T> bias, Options... options) {
+  public static <T extends TType> BiasAdd<T> create(Scope scope, Operand<T> value, Operand<T> bias, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BiasAdd", scope.makeOpName("BiasAdd"));
-    opBuilder.addInput(value.asOutput());
-    opBuilder.addInput(bias.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -109,7 +109,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ed6890c3649..ee31d4802ca 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * The backward operation for "BiasAdd" on the "bias" tensor.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class BiasAddGrad<T extends Tensor> extends RawOp implements Operand<T> {
+public final class BiasAddGrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BiasAddGrad}
@@ -73,9 +73,9 @@ private Options() {
    * @return a new instance of BiasAddGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BiasAddGrad<T> create(Scope scope, Operand<T> outBackprop, Options... options) {
+  public static <T extends TType> BiasAddGrad<T> create(Scope scope, Operand<T> outBackprop, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BiasAddGrad", scope.makeOpName("BiasAddGrad"));
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -108,7 +108,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ca1106a6c87..497fa707472 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -56,7 +55,7 @@
  * 
  * @param <T> data type for {@code i()} output
  */
-public final class BlockLSTM<T extends Tensor & TNumber> extends RawOp {
+public final class BlockLSTM<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.BlockLSTM}
@@ -104,17 +103,17 @@ private Options() {
    * @return a new instance of BlockLSTM
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BlockLSTM<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
+  public static <T extends TNumber> BlockLSTM<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BlockLSTMV2", scope.makeOpName("BlockLSTM"));
-    opBuilder.addInput(seqLenMax.asOutput());
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(csPrev.asOutput());
-    opBuilder.addInput(hPrev.asOutput());
-    opBuilder.addInput(w.asOutput());
-    opBuilder.addInput(wci.asOutput());
-    opBuilder.addInput(wcf.asOutput());
-    opBuilder.addInput(wco.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(seqLenMax.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(csPrev.asOutput(scope));
+    opBuilder.addInput(hPrev.asOutput(scope));
+    opBuilder.addInput(w.asOutput(scope));
+    opBuilder.addInput(wci.asOutput(scope));
+    opBuilder.addInput(wcf.asOutput(scope));
+    opBuilder.addInput(wco.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 6ec2880abc3..c1be585be53 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * 
  * @param <T> data type for {@code xGrad()} output
  */
-public final class BlockLSTMGrad<T extends Tensor & TNumber> extends RawOp {
+public final class BlockLSTMGrad<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BlockLSTMGrad operation.
@@ -65,26 +64,26 @@ public final class BlockLSTMGrad<T extends Tensor & TNumber> extends RawOp {
    * @return a new instance of BlockLSTMGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> BlockLSTMGrad<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> h, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
+  public static <T extends TNumber> BlockLSTMGrad<T> create(Scope scope, Operand<TInt64> seqLenMax, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> h, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
     OperationBuilder opBuilder = scope.env().opBuilder("BlockLSTMGradV2", scope.makeOpName("BlockLSTMGrad"));
-    opBuilder.addInput(seqLenMax.asOutput());
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(csPrev.asOutput());
-    opBuilder.addInput(hPrev.asOutput());
-    opBuilder.addInput(w.asOutput());
-    opBuilder.addInput(wci.asOutput());
-    opBuilder.addInput(wcf.asOutput());
-    opBuilder.addInput(wco.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(i.asOutput());
-    opBuilder.addInput(cs.asOutput());
-    opBuilder.addInput(f.asOutput());
-    opBuilder.addInput(o.asOutput());
-    opBuilder.addInput(ci.asOutput());
-    opBuilder.addInput(co.asOutput());
-    opBuilder.addInput(h.asOutput());
-    opBuilder.addInput(csGrad.asOutput());
-    opBuilder.addInput(hGrad.asOutput());
+    opBuilder.addInput(seqLenMax.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(csPrev.asOutput(scope));
+    opBuilder.addInput(hPrev.asOutput(scope));
+    opBuilder.addInput(w.asOutput(scope));
+    opBuilder.addInput(wci.asOutput(scope));
+    opBuilder.addInput(wcf.asOutput(scope));
+    opBuilder.addInput(wco.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(i.asOutput(scope));
+    opBuilder.addInput(cs.asOutput(scope));
+    opBuilder.addInput(f.asOutput(scope));
+    opBuilder.addInput(o.asOutput(scope));
+    opBuilder.addInput(ci.asOutput(scope));
+    opBuilder.addInput(co.asOutput(scope));
+    opBuilder.addInput(h.asOutput(scope));
+    opBuilder.addInput(csGrad.asOutput(scope));
+    opBuilder.addInput(hGrad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("use_peephole", usePeephole);
     return new BlockLSTMGrad<T>(opBuilder.build());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CTCLossV2.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CTCLossV2.java
index 918230851c3..d6d275cebb8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CTCLossV2.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/CTCLossV2.java
@@ -96,10 +96,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static CTCLossV2 create(Scope scope, Operand<TFloat32> inputs, Operand<TInt64> labelsIndices, Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CTCLossV2", scope.makeOpName("CTCLossV2"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(labelsIndices.asOutput());
-    opBuilder.addInput(labelsValues.asOutput());
-    opBuilder.addInput(sequenceLength.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(labelsIndices.asOutput(scope));
+    opBuilder.addInput(labelsValues.asOutput(scope));
+    opBuilder.addInput(sequenceLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 a11bb983ae9..98346cadd65 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
@@ -83,8 +83,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ComputeAccidentalHits create(Scope scope, Operand<TInt64> trueClasses, Operand<TInt64> sampledCandidates, Long numTrue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ComputeAccidentalHits", scope.makeOpName("ComputeAccidentalHits"));
-    opBuilder.addInput(trueClasses.asOutput());
-    opBuilder.addInput(sampledCandidates.asOutput());
+    opBuilder.addInput(trueClasses.asOutput(scope));
+    opBuilder.addInput(sampledCandidates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_true", numTrue);
     if (options != null) {
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 5a713b3cf1f..9345e242e2f 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -57,7 +56,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Conv2d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2d}
@@ -132,10 +131,10 @@ private Options() {
    * @return a new instance of Conv2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Conv2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> Conv2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv2D", scope.makeOpName("Conv2d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -218,7 +217,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 6adfcf516cf..0e2d0280bf3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2dBackpropFilter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Conv2dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2dBackpropFilter}
@@ -113,11 +112,11 @@ private Options() {
    * @return a new instance of Conv2dBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Conv2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> Conv2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv2DBackpropFilter", scope.makeOpName("Conv2dBackpropFilter"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filterSizes.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filterSizes.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -201,7 +200,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 73abfb16055..4fe74d158bc 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv2dBackpropInput<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Conv2dBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv2dBackpropInput}
@@ -113,11 +112,11 @@ private Options() {
    * @return a new instance of Conv2dBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Conv2dBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> Conv2dBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv2DBackpropInput", scope.makeOpName("Conv2dBackpropInput"));
-    opBuilder.addInput(inputSizes.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(inputSizes.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -200,7 +199,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 d73496a5402..36520489259 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -41,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Conv3d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3d}
@@ -93,10 +92,10 @@ private Options() {
    * @return a new instance of Conv3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Conv3d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> Conv3d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv3D", scope.makeOpName("Conv3d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -150,7 +149,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 45a628f4475..4eb64038363 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3dBackpropFilter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class Conv3dBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3dBackpropFilter}
@@ -92,11 +91,11 @@ private Options() {
    * @return a new instance of Conv3dBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Conv3dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> Conv3dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv3DBackpropFilterV2", scope.makeOpName("Conv3dBackpropFilter"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filterSizes.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filterSizes.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -150,7 +149,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 92fe9088aa8..0cb59575a5e 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Conv3dBackpropInput<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class Conv3dBackpropInput<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.Conv3dBackpropInput}
@@ -91,11 +90,11 @@ private Options() {
    * @return a new instance of Conv3dBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> Conv3dBackpropInput<U> create(Scope scope, Operand<T> inputSizes, Operand<U> filter, Operand<U> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <U extends TNumber, T extends TNumber> Conv3dBackpropInput<U> create(Scope scope, Operand<T> inputSizes, Operand<U> filter, Operand<U> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Conv3DBackpropInputV2", scope.makeOpName("Conv3dBackpropInput"));
-    opBuilder.addInput(inputSizes.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(inputSizes.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -149,7 +148,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 055c8cc9e4c..103b8adb152 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -44,7 +43,7 @@
  * @param <T> data type for {@code logProbability()} output
  */
 @Operator(group = "nn")
-public final class CtcBeamSearchDecoder<T extends Tensor & TNumber> extends RawOp {
+public final class CtcBeamSearchDecoder<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcBeamSearchDecoder}
@@ -77,10 +76,10 @@ private Options() {
    * @return a new instance of CtcBeamSearchDecoder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CtcBeamSearchDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths, Options... options) {
+  public static <T extends TNumber> CtcBeamSearchDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Long beamWidth, Long topPaths, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CTCBeamSearchDecoder", scope.makeOpName("CtcBeamSearchDecoder"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(sequenceLength.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(sequenceLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("beam_width", beamWidth);
     opBuilder.setAttr("top_paths", topPaths);
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 c32fd0b9bd6..84eaefbe4e9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -46,7 +45,7 @@
  * @param <T> data type for {@code logProbability()} output
  */
 @Operator(group = "nn")
-public final class CtcGreedyDecoder<T extends Tensor & TNumber> extends RawOp {
+public final class CtcGreedyDecoder<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcGreedyDecoder}
@@ -77,10 +76,10 @@ private Options() {
    * @return a new instance of CtcGreedyDecoder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CtcGreedyDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Options... options) {
+  public static <T extends TNumber> CtcGreedyDecoder<T> create(Scope scope, Operand<T> inputs, Operand<TInt32> sequenceLength, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CTCGreedyDecoder", scope.makeOpName("CtcGreedyDecoder"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(sequenceLength.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(sequenceLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 ab5bff6dc1d..fee78baaeac 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class CtcLoss<T extends Tensor & TNumber> extends RawOp {
+public final class CtcLoss<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CtcLoss}
@@ -97,12 +96,12 @@ private Options() {
    * @return a new instance of CtcLoss
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CtcLoss<T> create(Scope scope, Operand<T> inputs, Operand<TInt64> labelsIndices, Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength, Options... options) {
+  public static <T extends TNumber> CtcLoss<T> create(Scope scope, Operand<T> inputs, Operand<TInt64> labelsIndices, Operand<TInt32> labelsValues, Operand<TInt32> sequenceLength, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CTCLoss", scope.makeOpName("CtcLoss"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(labelsIndices.asOutput());
-    opBuilder.addInput(labelsValues.asOutput());
-    opBuilder.addInput(sequenceLength.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(labelsIndices.asOutput(scope));
+    opBuilder.addInput(labelsValues.asOutput(scope));
+    opBuilder.addInput(sequenceLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 c083d7618be..25294d15ec3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -72,7 +71,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CudnnRNN<T extends Tensor & TNumber> extends RawOp {
+public final class CudnnRNN<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNN}
@@ -178,13 +177,13 @@ private Options() {
    * @return a new instance of CudnnRNN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CudnnRNN<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Options... options) {
+  public static <T extends TNumber> CudnnRNN<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNV3", scope.makeOpName("CudnnRNN"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputH.asOutput());
-    opBuilder.addInput(inputC.asOutput());
-    opBuilder.addInput(params.asOutput());
-    opBuilder.addInput(sequenceLengths.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputH.asOutput(scope));
+    opBuilder.addInput(inputC.asOutput(scope));
+    opBuilder.addInput(params.asOutput(scope));
+    opBuilder.addInput(sequenceLengths.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 d16c49f0c59..a7424b97117 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -82,7 +81,7 @@
  * 
  * @param <T> data type for {@code inputBackprop()} output
  */
-public final class CudnnRNNBackprop<T extends Tensor & TNumber> extends RawOp {
+public final class CudnnRNNBackprop<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNBackprop}
@@ -187,21 +186,21 @@ private Options() {
    * @return a new instance of CudnnRNNBackprop
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CudnnRNNBackprop<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Operand<T> output, Operand<T> outputH, Operand<T> outputC, Operand<T> outputBackprop, Operand<T> outputHBackprop, Operand<T> outputCBackprop, Operand<T> reserveSpace, Operand<?> hostReserved, Options... options) {
+  public static <T extends TNumber> CudnnRNNBackprop<T> create(Scope scope, Operand<T> input, Operand<T> inputH, Operand<T> inputC, Operand<T> params, Operand<TInt32> sequenceLengths, Operand<T> output, Operand<T> outputH, Operand<T> outputC, Operand<T> outputBackprop, Operand<T> outputHBackprop, Operand<T> outputCBackprop, Operand<T> reserveSpace, Operand<?> hostReserved, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNBackpropV3", scope.makeOpName("CudnnRNNBackprop"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputH.asOutput());
-    opBuilder.addInput(inputC.asOutput());
-    opBuilder.addInput(params.asOutput());
-    opBuilder.addInput(sequenceLengths.asOutput());
-    opBuilder.addInput(output.asOutput());
-    opBuilder.addInput(outputH.asOutput());
-    opBuilder.addInput(outputC.asOutput());
-    opBuilder.addInput(outputBackprop.asOutput());
-    opBuilder.addInput(outputHBackprop.asOutput());
-    opBuilder.addInput(outputCBackprop.asOutput());
-    opBuilder.addInput(reserveSpace.asOutput());
-    opBuilder.addInput(hostReserved.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputH.asOutput(scope));
+    opBuilder.addInput(inputC.asOutput(scope));
+    opBuilder.addInput(params.asOutput(scope));
+    opBuilder.addInput(sequenceLengths.asOutput(scope));
+    opBuilder.addInput(output.asOutput(scope));
+    opBuilder.addInput(outputH.asOutput(scope));
+    opBuilder.addInput(outputC.asOutput(scope));
+    opBuilder.addInput(outputBackprop.asOutput(scope));
+    opBuilder.addInput(outputHBackprop.asOutput(scope));
+    opBuilder.addInput(outputCBackprop.asOutput(scope));
+    opBuilder.addInput(reserveSpace.asOutput(scope));
+    opBuilder.addInput(hostReserved.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 d1cf41a5038..dea37f64f78 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
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -67,7 +66,7 @@
  * @param <T> data type for {@code params()} output
  */
 @Operator(group = "nn")
-public final class CudnnRNNCanonicalToParams<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class CudnnRNNCanonicalToParams<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNCanonicalToParams}
@@ -155,13 +154,13 @@ private Options() {
    * @return a new instance of CudnnRNNCanonicalToParams
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CudnnRNNCanonicalToParams<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Iterable<Operand<T>> weights, Iterable<Operand<T>> biases, Options... options) {
+  public static <T extends TNumber> CudnnRNNCanonicalToParams<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Iterable<Operand<T>> weights, Iterable<Operand<T>> biases, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNCanonicalToParamsV2", scope.makeOpName("CudnnRNNCanonicalToParams"));
-    opBuilder.addInput(numLayers.asOutput());
-    opBuilder.addInput(numUnits.asOutput());
-    opBuilder.addInput(inputSize.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(weights));
-    opBuilder.addInputList(Operands.asOutputs(biases));
+    opBuilder.addInput(numLayers.asOutput(scope));
+    opBuilder.addInput(numUnits.asOutput(scope));
+    opBuilder.addInput(inputSize.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, weights));
+    opBuilder.addInputList(Operands.asOutputs(scope, biases));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -247,7 +246,7 @@ public Output<T> params() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return params;
   }
   
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 e9342852933..2bebca47eb7 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -68,7 +67,7 @@
  * @param <T> data type for {@code weights()} output
  */
 @Operator(group = "nn")
-public final class CudnnRNNParamsToCanonical<T extends Tensor & TNumber> extends RawOp {
+public final class CudnnRNNParamsToCanonical<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRNNParamsToCanonical}
@@ -157,12 +156,12 @@ private Options() {
    * @return a new instance of CudnnRNNParamsToCanonical
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CudnnRNNParamsToCanonical<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Operand<T> params, Long numParamsWeights, Long numParamsBiases, Options... options) {
+  public static <T extends TNumber> CudnnRNNParamsToCanonical<T> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, Operand<T> params, Long numParamsWeights, Long numParamsBiases, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNParamsToCanonicalV2", scope.makeOpName("CudnnRNNParamsToCanonical"));
-    opBuilder.addInput(numLayers.asOutput());
-    opBuilder.addInput(numUnits.asOutput());
-    opBuilder.addInput(inputSize.asOutput());
-    opBuilder.addInput(params.asOutput());
+    opBuilder.addInput(numLayers.asOutput(scope));
+    opBuilder.addInput(numUnits.asOutput(scope));
+    opBuilder.addInput(inputSize.asOutput(scope));
+    opBuilder.addInput(params.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_params_weights", numParamsWeights);
     opBuilder.setAttr("num_params_biases", numParamsBiases);
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 753c35f4fec..3b79189560b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -58,7 +57,7 @@
  * @param <U> data type for {@code paramsSize()} output
  */
 @Operator(group = "nn")
-public final class CudnnRnnParamsSize<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class CudnnRnnParamsSize<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.CudnnRnnParamsSize}
@@ -146,11 +145,11 @@ private Options() {
    * @return a new instance of CudnnRnnParamsSize
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> CudnnRnnParamsSize<U> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, DataType<T> T, DataType<U> S, Options... options) {
+  public static <U extends TNumber, T extends TNumber> CudnnRnnParamsSize<U> create(Scope scope, Operand<TInt32> numLayers, Operand<TInt32> numUnits, Operand<TInt32> inputSize, DataType<T> T, DataType<U> S, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("CudnnRNNParamsSize", scope.makeOpName("CudnnRnnParamsSize"));
-    opBuilder.addInput(numLayers.asOutput());
-    opBuilder.addInput(numUnits.asOutput());
-    opBuilder.addInput(inputSize.asOutput());
+    opBuilder.addInput(numLayers.asOutput(scope));
+    opBuilder.addInput(numUnits.asOutput(scope));
+    opBuilder.addInput(inputSize.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("T", T);
     opBuilder.setAttr("S", S);
@@ -238,7 +237,7 @@ public Output<U> paramsSize() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return paramsSize;
   }
   
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 b0684f2462b..b495320513c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class DataFormatDimMap<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class DataFormatDimMap<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DataFormatDimMap}
@@ -76,9 +75,9 @@ private Options() {
    * @return a new instance of DataFormatDimMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DataFormatDimMap<T> create(Scope scope, Operand<T> x, Options... options) {
+  public static <T extends TNumber> DataFormatDimMap<T> create(Scope scope, Operand<T> x, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DataFormatDimMap", scope.makeOpName("DataFormatDimMap"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -115,7 +114,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 b7aa7357ff6..91e2ba14b89 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class DataFormatVecPermute<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class DataFormatVecPermute<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DataFormatVecPermute}
@@ -75,9 +74,9 @@ private Options() {
    * @return a new instance of DataFormatVecPermute
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DataFormatVecPermute<T> create(Scope scope, Operand<T> x, Options... options) {
+  public static <T extends TNumber> DataFormatVecPermute<T> create(Scope scope, Operand<T> x, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DataFormatVecPermute", scope.makeOpName("DataFormatVecPermute"));
-    opBuilder.addInput(x.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -114,7 +113,7 @@ public Output<T> y() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return y;
   }
   
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 94085de3dda..01ee5ece664 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * DepthToSpace for tensors of type T.
@@ -113,7 +113,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthToSpace<T extends Tensor> extends RawOp implements Operand<T> {
+public final class DepthToSpace<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthToSpace}
@@ -144,9 +144,9 @@ private Options() {
    * @return a new instance of DepthToSpace
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DepthToSpace<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
+  public static <T extends TType> DepthToSpace<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthToSpace", scope.makeOpName("DepthToSpace"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("block_size", blockSize);
     if (options != null) {
@@ -173,7 +173,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 21045735cc0..dd517907f60 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -52,7 +51,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNative<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class DepthwiseConv2dNative<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNative}
@@ -103,10 +102,10 @@ private Options() {
    * @return a new instance of DepthwiseConv2dNative
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DepthwiseConv2dNative<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> DepthwiseConv2dNative<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthwiseConv2dNative", scope.makeOpName("DepthwiseConv2dNative"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -160,7 +159,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 bd49bd1525a..5f66105c000 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNativeBackpropFilter<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class DepthwiseConv2dNativeBackpropFilter<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNativeBackpropFilter}
@@ -95,11 +94,11 @@ private Options() {
    * @return a new instance of DepthwiseConv2dNativeBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> DepthwiseConv2dNativeBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<TInt32> filterSizes, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthwiseConv2dNativeBackpropFilter", scope.makeOpName("DepthwiseConv2dNativeBackpropFilter"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filterSizes.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filterSizes.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -156,7 +155,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c61e9f23c55..e25e937bc9c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class DepthwiseConv2dNativeBackpropInput<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class DepthwiseConv2dNativeBackpropInput<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.DepthwiseConv2dNativeBackpropInput}
@@ -94,11 +93,11 @@ private Options() {
    * @return a new instance of DepthwiseConv2dNativeBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> DepthwiseConv2dNativeBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> DepthwiseConv2dNativeBackpropInput<T> create(Scope scope, Operand<TInt32> inputSizes, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DepthwiseConv2dNativeBackpropInput", scope.makeOpName("DepthwiseConv2dNativeBackpropInput"));
-    opBuilder.addInput(inputSizes.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(inputSizes.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -156,7 +155,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 364aaf593ba..b1ea894ab18 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -59,7 +58,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class Dilation2d<T extends Tensor & TNumber> extends RawOp 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.
@@ -75,10 +74,10 @@ public final class Dilation2d<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of Dilation2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Dilation2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends TNumber> Dilation2d<T> create(Scope scope, Operand<T> input, Operand<T> filter, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dilation2D", scope.makeOpName("Dilation2d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -102,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 1456056f66e..ab9ae4d8d7c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code filterBackprop()} output
  */
 @Operator(group = "nn")
-public final class Dilation2dBackpropFilter<T extends Tensor & TNumber> extends RawOp 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.
@@ -52,11 +51,11 @@ public final class Dilation2dBackpropFilter<T extends Tensor & TNumber> extends
    * @return a new instance of Dilation2dBackpropFilter
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Dilation2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends TNumber> Dilation2dBackpropFilter<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dilation2DBackpropFilter", scope.makeOpName("Dilation2dBackpropFilter"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -80,7 +79,7 @@ public Output<T> filterBackprop() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return filterBackprop;
   }
   
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 5b64c67344c..8a3e6510a00 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code inBackprop()} output
  */
 @Operator(group = "nn")
-public final class Dilation2dBackpropInput<T extends Tensor & TNumber> extends RawOp 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.
@@ -52,11 +51,11 @@ public final class Dilation2dBackpropInput<T extends Tensor & TNumber> extends R
    * @return a new instance of Dilation2dBackpropInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Dilation2dBackpropInput<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
+  public static <T extends TNumber> Dilation2dBackpropInput<T> create(Scope scope, Operand<T> input, Operand<T> filter, Operand<T> outBackprop, List<Long> strides, List<Long> rates, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dilation2DBackpropInput", scope.makeOpName("Dilation2dBackpropInput"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] stridesArray = new long[strides.size()];
     for (int i = 0; i < stridesArray.length; ++i) {
@@ -80,7 +79,7 @@ public Output<T> inBackprop() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return inBackprop;
   }
   
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 199dabaf52d..c0233a2da82 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Elu<T extends Tensor & TNumber> extends RawOp 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.
@@ -47,9 +46,9 @@ public final class Elu<T extends Tensor & TNumber> extends RawOp implements Oper
    * @return a new instance of Elu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Elu<T> create(Scope scope, Operand<T> features) {
+  public static <T extends TNumber> Elu<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Elu", scope.makeOpName("Elu"));
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Elu<T>(opBuilder.build());
   }
@@ -61,7 +60,7 @@ public Output<T> activations() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return activations;
   }
   
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 d53fc754996..331c5812449 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class EluGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,10 +43,10 @@ public final class EluGrad<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of EluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> EluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
+  public static <T extends TNumber> EluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("EluGrad", scope.makeOpName("EluGrad"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(outputs.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(outputs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new EluGrad<T>(opBuilder.build());
   }
@@ -61,7 +60,7 @@ public Output<T> backprops() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return backprops;
   }
   
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 e99a41a2c56..cf31cd0c75e 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
@@ -169,7 +169,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static FixedUnigramCandidateSampler create(Scope scope, Operand<TInt64> trueClasses, Long numTrue, Long numSampled, Boolean unique, Long rangeMax, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FixedUnigramCandidateSampler", scope.makeOpName("FixedUnigramCandidateSampler"));
-    opBuilder.addInput(trueClasses.asOutput());
+    opBuilder.addInput(trueClasses.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_true", numTrue);
     opBuilder.setAttr("num_sampled", numSampled);
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 fb25c90796a..4b67b26943a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -41,7 +40,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FractionalAvgPool<T extends Tensor & TNumber> extends RawOp {
+public final class FractionalAvgPool<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalAvgPool}
@@ -128,9 +127,9 @@ private Options() {
    * @return a new instance of FractionalAvgPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FractionalAvgPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
+  public static <T extends TNumber> FractionalAvgPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalAvgPool", scope.makeOpName("FractionalAvgPool"));
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     float[] poolingRatioArray = new float[poolingRatio.size()];
     for (int i = 0; i < poolingRatioArray.length; ++i) {
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 858d75fd13b..62b89928f8b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class FractionalAvgPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class FractionalAvgPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalAvgPoolGrad}
@@ -84,12 +83,12 @@ private Options() {
    * @return a new instance of FractionalAvgPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FractionalAvgPoolGrad<T> create(Scope scope, Operand<TInt64> origInputTensorShape, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
+  public static <T extends TNumber> FractionalAvgPoolGrad<T> create(Scope scope, Operand<TInt64> origInputTensorShape, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalAvgPoolGrad", scope.makeOpName("FractionalAvgPoolGrad"));
-    opBuilder.addInput(origInputTensorShape.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
-    opBuilder.addInput(rowPoolingSequence.asOutput());
-    opBuilder.addInput(colPoolingSequence.asOutput());
+    opBuilder.addInput(origInputTensorShape.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
+    opBuilder.addInput(rowPoolingSequence.asOutput(scope));
+    opBuilder.addInput(colPoolingSequence.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -124,7 +123,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a243ac7ef0a..e9fa329faf1 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -65,7 +64,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FractionalMaxPool<T extends Tensor & TNumber> extends RawOp {
+public final class FractionalMaxPool<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalMaxPool}
@@ -152,9 +151,9 @@ private Options() {
    * @return a new instance of FractionalMaxPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FractionalMaxPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
+  public static <T extends TNumber> FractionalMaxPool<T> create(Scope scope, Operand<T> value, List<Float> poolingRatio, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalMaxPool", scope.makeOpName("FractionalMaxPool"));
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     float[] poolingRatioArray = new float[poolingRatio.size()];
     for (int i = 0; i < poolingRatioArray.length; ++i) {
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 b1290e0096f..95dc04ec01e 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class FractionalMaxPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class FractionalMaxPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FractionalMaxPoolGrad}
@@ -79,13 +78,13 @@ private Options() {
    * @return a new instance of FractionalMaxPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FractionalMaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
+  public static <T extends TNumber> FractionalMaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> outBackprop, Operand<TInt64> rowPoolingSequence, Operand<TInt64> colPoolingSequence, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FractionalMaxPoolGrad", scope.makeOpName("FractionalMaxPoolGrad"));
-    opBuilder.addInput(origInput.asOutput());
-    opBuilder.addInput(origOutput.asOutput());
-    opBuilder.addInput(outBackprop.asOutput());
-    opBuilder.addInput(rowPoolingSequence.asOutput());
-    opBuilder.addInput(colPoolingSequence.asOutput());
+    opBuilder.addInput(origInput.asOutput(scope));
+    opBuilder.addInput(origOutput.asOutput(scope));
+    opBuilder.addInput(outBackprop.asOutput(scope));
+    opBuilder.addInput(rowPoolingSequence.asOutput(scope));
+    opBuilder.addInput(colPoolingSequence.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -120,7 +119,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 e87464074e9..3351661b52a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <U> data type for {@code batchMean()} output
  */
 @Operator(group = "nn")
-public final class FusedBatchNorm<T extends Tensor & TNumber, U extends Tensor & TNumber> extends RawOp {
+public final class FusedBatchNorm<T extends TNumber, U extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedBatchNorm}
@@ -102,13 +101,13 @@ private Options() {
    * @return a new instance of FusedBatchNorm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNorm<T, U> create(Scope scope, Operand<T> x, Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance, Options... options) {
+  public static <T extends TNumber, U extends TNumber> FusedBatchNorm<T, U> create(Scope scope, Operand<T> x, Operand<U> scale, Operand<U> offset, Operand<U> mean, Operand<U> variance, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedBatchNormV3", scope.makeOpName("FusedBatchNorm"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(scale.asOutput());
-    opBuilder.addInput(offset.asOutput());
-    opBuilder.addInput(mean.asOutput());
-    opBuilder.addInput(variance.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(scale.asOutput(scope));
+    opBuilder.addInput(offset.asOutput(scope));
+    opBuilder.addInput(mean.asOutput(scope));
+    opBuilder.addInput(variance.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 4cc599672c2..ba0e0e7dbac 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * @param <U> data type for {@code scaleBackprop()} output
  */
 @Operator(group = "nn")
-public final class FusedBatchNormGrad<T extends Tensor & TNumber, U extends Tensor & TNumber> extends RawOp {
+public final class FusedBatchNormGrad<T extends TNumber, U extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedBatchNormGrad}
@@ -103,14 +102,14 @@ private Options() {
    * @return a new instance of FusedBatchNormGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> FusedBatchNormGrad<T, U> create(Scope scope, Operand<T> yBackprop, Operand<T> x, Operand<TFloat32> scale, Operand<U> reserveSpace1, Operand<U> reserveSpace2, Operand<U> reserveSpace3, Options... options) {
+  public static <T extends TNumber, U extends TNumber> FusedBatchNormGrad<T, U> create(Scope scope, Operand<T> yBackprop, Operand<T> x, Operand<TFloat32> scale, Operand<U> reserveSpace1, Operand<U> reserveSpace2, Operand<U> reserveSpace3, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedBatchNormGradV3", scope.makeOpName("FusedBatchNormGrad"));
-    opBuilder.addInput(yBackprop.asOutput());
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(scale.asOutput());
-    opBuilder.addInput(reserveSpace1.asOutput());
-    opBuilder.addInput(reserveSpace2.asOutput());
-    opBuilder.addInput(reserveSpace3.asOutput());
+    opBuilder.addInput(yBackprop.asOutput(scope));
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(scale.asOutput(scope));
+    opBuilder.addInput(reserveSpace1.asOutput(scope));
+    opBuilder.addInput(reserveSpace2.asOutput(scope));
+    opBuilder.addInput(reserveSpace3.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 59761847b9d..93cd92cebff 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -48,7 +47,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FusedPadConv2d<T extends Tensor & TNumber> extends RawOp 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.
@@ -66,11 +65,11 @@ public final class FusedPadConv2d<T extends Tensor & TNumber> extends RawOp impl
    * @return a new instance of FusedPadConv2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FusedPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding) {
+  public static <T extends TNumber> FusedPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedPadConv2D", scope.makeOpName("FusedPadConv2d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(paddings.asOutput());
-    opBuilder.addInput(filter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(paddings.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("mode", mode);
     long[] stridesArray = new long[strides.size()];
@@ -89,7 +88,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 4df54a3e2ab..77fde62f410 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -47,7 +46,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class FusedResizeAndPadConv2d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class FusedResizeAndPadConv2d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.FusedResizeAndPadConv2d}
@@ -88,12 +87,12 @@ private Options() {
    * @return a new instance of FusedResizeAndPadConv2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> FusedResizeAndPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> FusedResizeAndPadConv2d<T> create(Scope scope, Operand<T> input, Operand<TInt32> size, Operand<TInt32> paddings, Operand<T> filter, String mode, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FusedResizeAndPadConv2D", scope.makeOpName("FusedResizeAndPadConv2d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(size.asOutput());
-    opBuilder.addInput(paddings.asOutput());
-    opBuilder.addInput(filter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
+    opBuilder.addInput(paddings.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("mode", mode);
     long[] stridesArray = new long[strides.size()];
@@ -127,7 +126,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 aef0518ba41..99b1963eb01 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -78,7 +77,7 @@
  * 
  * @param <T> data type for {@code r()} output
  */
-public final class GRUBlockCell<T extends Tensor & TNumber> extends RawOp {
+public final class GRUBlockCell<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new GRUBlockCell operation.
@@ -93,14 +92,14 @@ public final class GRUBlockCell<T extends Tensor & TNumber> extends RawOp {
    * @return a new instance of GRUBlockCell
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> GRUBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC) {
+  public static <T extends TNumber> GRUBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC) {
     OperationBuilder opBuilder = scope.env().opBuilder("GRUBlockCell", scope.makeOpName("GRUBlockCell"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(hPrev.asOutput());
-    opBuilder.addInput(wRu.asOutput());
-    opBuilder.addInput(wC.asOutput());
-    opBuilder.addInput(bRu.asOutput());
-    opBuilder.addInput(bC.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(hPrev.asOutput(scope));
+    opBuilder.addInput(wRu.asOutput(scope));
+    opBuilder.addInput(wC.asOutput(scope));
+    opBuilder.addInput(bRu.asOutput(scope));
+    opBuilder.addInput(bC.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new GRUBlockCell<T>(opBuilder.build());
   }
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 b971b3afb62..61c2f989d49 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -114,7 +113,7 @@
  * 
  * @param <T> data type for {@code dX()} output
  */
-public final class GRUBlockCellGrad<T extends Tensor & TNumber> extends RawOp {
+public final class GRUBlockCellGrad<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new GRUBlockCellGrad operation.
@@ -133,18 +132,18 @@ public final class GRUBlockCellGrad<T extends Tensor & TNumber> extends RawOp {
    * @return a new instance of GRUBlockCellGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> GRUBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC, Operand<T> r, Operand<T> u, Operand<T> c, Operand<T> dH) {
+  public static <T extends TNumber> GRUBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> hPrev, Operand<T> wRu, Operand<T> wC, Operand<T> bRu, Operand<T> bC, Operand<T> r, Operand<T> u, Operand<T> c, Operand<T> dH) {
     OperationBuilder opBuilder = scope.env().opBuilder("GRUBlockCellGrad", scope.makeOpName("GRUBlockCellGrad"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(hPrev.asOutput());
-    opBuilder.addInput(wRu.asOutput());
-    opBuilder.addInput(wC.asOutput());
-    opBuilder.addInput(bRu.asOutput());
-    opBuilder.addInput(bC.asOutput());
-    opBuilder.addInput(r.asOutput());
-    opBuilder.addInput(u.asOutput());
-    opBuilder.addInput(c.asOutput());
-    opBuilder.addInput(dH.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(hPrev.asOutput(scope));
+    opBuilder.addInput(wRu.asOutput(scope));
+    opBuilder.addInput(wC.asOutput(scope));
+    opBuilder.addInput(bRu.asOutput(scope));
+    opBuilder.addInput(bC.asOutput(scope));
+    opBuilder.addInput(r.asOutput(scope));
+    opBuilder.addInput(u.asOutput(scope));
+    opBuilder.addInput(c.asOutput(scope));
+    opBuilder.addInput(dH.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new GRUBlockCellGrad<T>(opBuilder.build());
   }
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 2a1a9aff9ca..67c468cd1f6 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -61,11 +60,11 @@ public final class InTopK extends RawOp implements Operand<TBool> {
    * @return a new instance of InTopK
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> InTopK create(Scope scope, Operand<TFloat32> predictions, Operand<T> targets, Operand<T> k) {
+  public static <T extends TNumber> InTopK create(Scope scope, Operand<TFloat32> predictions, Operand<T> targets, Operand<T> k) {
     OperationBuilder opBuilder = scope.env().opBuilder("InTopKV2", scope.makeOpName("InTopK"));
-    opBuilder.addInput(predictions.asOutput());
-    opBuilder.addInput(targets.asOutput());
-    opBuilder.addInput(k.asOutput());
+    opBuilder.addInput(predictions.asOutput(scope));
+    opBuilder.addInput(targets.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new InTopK(opBuilder.build());
   }
@@ -78,7 +77,7 @@ public Output<TBool> precision() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return precision;
   }
   
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 e4c358a2481..a6446c43892 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the gradient for the inverse of `x` wrt its input.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code z()} output
  */
-public final class InvGrad<T extends Tensor> extends RawOp 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.
@@ -46,10 +46,10 @@ public final class InvGrad<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of InvGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> InvGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
+  public static <T extends TType> InvGrad<T> create(Scope scope, Operand<T> y, Operand<T> dy) {
     OperationBuilder opBuilder = scope.env().opBuilder("InvGrad", scope.makeOpName("InvGrad"));
-    opBuilder.addInput(y.asOutput());
-    opBuilder.addInput(dy.asOutput());
+    opBuilder.addInput(y.asOutput(scope));
+    opBuilder.addInput(dy.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new InvGrad<T>(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<T> z() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return z;
   }
   
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 04542e7117a..162601f35e8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class L2Loss<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,9 +47,9 @@ public final class L2Loss<T extends Tensor & TNumber> extends RawOp implements O
    * @return a new instance of L2Loss
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> L2Loss<T> create(Scope scope, Operand<T> t) {
+  public static <T extends TNumber> L2Loss<T> create(Scope scope, Operand<T> t) {
     OperationBuilder opBuilder = scope.env().opBuilder("L2Loss", scope.makeOpName("L2Loss"));
-    opBuilder.addInput(t.asOutput());
+    opBuilder.addInput(t.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new L2Loss<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 3bbf9690e13..d81d2a82a6a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -58,7 +57,7 @@
  * 
  * @param <T> data type for {@code i()} output
  */
-public final class LSTMBlockCell<T extends Tensor & TNumber> extends RawOp {
+public final class LSTMBlockCell<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LSTMBlockCell}
@@ -113,16 +112,16 @@ private Options() {
    * @return a new instance of LSTMBlockCell
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LSTMBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
+  public static <T extends TNumber> LSTMBlockCell<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LSTMBlockCell", scope.makeOpName("LSTMBlockCell"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(csPrev.asOutput());
-    opBuilder.addInput(hPrev.asOutput());
-    opBuilder.addInput(w.asOutput());
-    opBuilder.addInput(wci.asOutput());
-    opBuilder.addInput(wcf.asOutput());
-    opBuilder.addInput(wco.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(csPrev.asOutput(scope));
+    opBuilder.addInput(hPrev.asOutput(scope));
+    opBuilder.addInput(w.asOutput(scope));
+    opBuilder.addInput(wci.asOutput(scope));
+    opBuilder.addInput(wcf.asOutput(scope));
+    opBuilder.addInput(wco.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 f3c8a9d2823..435d59abbdb 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * 
  * @param <T> data type for {@code csPrevGrad()} output
  */
-public final class LSTMBlockCellGrad<T extends Tensor & TNumber> extends RawOp {
+public final class LSTMBlockCellGrad<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new LSTMBlockCellGrad operation.
@@ -61,24 +60,24 @@ public final class LSTMBlockCellGrad<T extends Tensor & TNumber> extends RawOp {
    * @return a new instance of LSTMBlockCellGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LSTMBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
+  public static <T extends TNumber> LSTMBlockCellGrad<T> create(Scope scope, Operand<T> x, Operand<T> csPrev, Operand<T> hPrev, Operand<T> w, Operand<T> wci, Operand<T> wcf, Operand<T> wco, Operand<T> b, Operand<T> i, Operand<T> cs, Operand<T> f, Operand<T> o, Operand<T> ci, Operand<T> co, Operand<T> csGrad, Operand<T> hGrad, Boolean usePeephole) {
     OperationBuilder opBuilder = scope.env().opBuilder("LSTMBlockCellGrad", scope.makeOpName("LSTMBlockCellGrad"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(csPrev.asOutput());
-    opBuilder.addInput(hPrev.asOutput());
-    opBuilder.addInput(w.asOutput());
-    opBuilder.addInput(wci.asOutput());
-    opBuilder.addInput(wcf.asOutput());
-    opBuilder.addInput(wco.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(i.asOutput());
-    opBuilder.addInput(cs.asOutput());
-    opBuilder.addInput(f.asOutput());
-    opBuilder.addInput(o.asOutput());
-    opBuilder.addInput(ci.asOutput());
-    opBuilder.addInput(co.asOutput());
-    opBuilder.addInput(csGrad.asOutput());
-    opBuilder.addInput(hGrad.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(csPrev.asOutput(scope));
+    opBuilder.addInput(hPrev.asOutput(scope));
+    opBuilder.addInput(w.asOutput(scope));
+    opBuilder.addInput(wci.asOutput(scope));
+    opBuilder.addInput(wcf.asOutput(scope));
+    opBuilder.addInput(wco.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(i.asOutput(scope));
+    opBuilder.addInput(cs.asOutput(scope));
+    opBuilder.addInput(f.asOutput(scope));
+    opBuilder.addInput(o.asOutput(scope));
+    opBuilder.addInput(ci.asOutput(scope));
+    opBuilder.addInput(co.asOutput(scope));
+    opBuilder.addInput(csGrad.asOutput(scope));
+    opBuilder.addInput(hGrad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("use_peephole", usePeephole);
     return new LSTMBlockCellGrad<T>(opBuilder.build());
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 c9e9c98be21..02fd19683d7 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code activations()} output
  */
-public final class LeakyRelu<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class LeakyRelu<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LeakyRelu}
@@ -63,9 +62,9 @@ private Options() {
    * @return a new instance of LeakyRelu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LeakyRelu<T> create(Scope scope, Operand<T> features, Options... options) {
+  public static <T extends TNumber> LeakyRelu<T> create(Scope scope, Operand<T> features, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LeakyRelu", scope.makeOpName("LeakyRelu"));
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -91,7 +90,7 @@ public Output<T> activations() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return activations;
   }
   
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 017ee428cde..548e25eece7 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
@@ -92,7 +92,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LearnedUnigramCandidateSampler create(Scope scope, Operand<TInt64> trueClasses, Long numTrue, Long numSampled, Boolean unique, Long rangeMax, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LearnedUnigramCandidateSampler", scope.makeOpName("LearnedUnigramCandidateSampler"));
-    opBuilder.addInput(trueClasses.asOutput());
+    opBuilder.addInput(trueClasses.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_true", numTrue);
     opBuilder.setAttr("num_sampled", numSampled);
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 823731dca6b..253dddae244 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -46,7 +45,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class LocalResponseNormalization<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class LocalResponseNormalization<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LocalResponseNormalization}
@@ -103,9 +102,9 @@ private Options() {
    * @return a new instance of LocalResponseNormalization
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LocalResponseNormalization<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TNumber> LocalResponseNormalization<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LRN", scope.makeOpName("LocalResponseNormalization"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -161,7 +160,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 8c15dbb937c..5939d159c12 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class LocalResponseNormalizationGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class LocalResponseNormalizationGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.LocalResponseNormalizationGrad}
@@ -92,11 +91,11 @@ private Options() {
    * @return a new instance of LocalResponseNormalizationGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LocalResponseNormalizationGrad<T> create(Scope scope, Operand<T> inputGrads, Operand<T> inputImage, Operand<T> outputImage, Options... options) {
+  public static <T extends TNumber> LocalResponseNormalizationGrad<T> create(Scope scope, Operand<T> inputGrads, Operand<T> inputImage, Operand<T> outputImage, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LRNGrad", scope.makeOpName("LocalResponseNormalizationGrad"));
-    opBuilder.addInput(inputGrads.asOutput());
-    opBuilder.addInput(inputImage.asOutput());
-    opBuilder.addInput(outputImage.asOutput());
+    opBuilder.addInput(inputGrads.asOutput(scope));
+    opBuilder.addInput(inputImage.asOutput(scope));
+    opBuilder.addInput(outputImage.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -153,7 +152,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 e2bdf72d1ff..a324d30f348 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code logsoftmax()} output
  */
 @Operator(group = "nn")
-public final class LogSoftmax<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,9 +47,9 @@ public final class LogSoftmax<T extends Tensor & TNumber> extends RawOp implemen
    * @return a new instance of LogSoftmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> LogSoftmax<T> create(Scope scope, Operand<T> logits) {
+  public static <T extends TNumber> LogSoftmax<T> create(Scope scope, Operand<T> logits) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogSoftmax", scope.makeOpName("LogSoftmax"));
-    opBuilder.addInput(logits.asOutput());
+    opBuilder.addInput(logits.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new LogSoftmax<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> logsoftmax() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return logsoftmax;
   }
   
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 1f04b7e6365..fb95e33d515 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Performs max pooling on the input.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool<T extends Tensor> extends RawOp implements Operand<T> {
+public final class MaxPool<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool}
@@ -72,11 +72,11 @@ private Options() {
    * @return a new instance of MaxPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> MaxPool<T> create(Scope scope, Operand<T> input, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
+  public static <T extends TType> MaxPool<T> create(Scope scope, Operand<T> input, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolV2", scope.makeOpName("MaxPool"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(ksize.asOutput());
-    opBuilder.addInput(strides.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(ksize.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("padding", padding);
     if (options != null) {
@@ -108,7 +108,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 9718086f92f..059a4a8943c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3d<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class MaxPool3d<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3d}
@@ -74,9 +73,9 @@ private Options() {
    * @return a new instance of MaxPool3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> MaxPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> MaxPool3d<T> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPool3D", scope.makeOpName("MaxPool3d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -118,7 +117,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5fc4ee59e7a..99fe0c64064 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3dGrad<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class MaxPool3dGrad<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3dGrad}
@@ -76,11 +75,11 @@ private Options() {
    * @return a new instance of MaxPool3dGrad
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> MaxPool3dGrad<U> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<U> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <U extends TNumber, T extends TNumber> MaxPool3dGrad<U> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<U> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPool3DGrad", scope.makeOpName("MaxPool3dGrad"));
-    opBuilder.addInput(origInput.asOutput());
-    opBuilder.addInput(origOutput.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(origInput.asOutput(scope));
+    opBuilder.addInput(origOutput.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -121,7 +120,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 1e823be32df..9cf17ec2379 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPool3dGradGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class MaxPool3dGradGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPool3dGradGrad}
@@ -76,11 +75,11 @@ private Options() {
    * @return a new instance of MaxPool3dGradGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> MaxPool3dGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> MaxPool3dGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPool3DGradGrad", scope.makeOpName("MaxPool3dGradGrad"));
-    opBuilder.addInput(origInput.asOutput());
-    opBuilder.addInput(origOutput.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(origInput.asOutput(scope));
+    opBuilder.addInput(origOutput.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -122,7 +121,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ef85953d548..ff103553ca4 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGrad}
@@ -75,13 +74,13 @@ private Options() {
    * @return a new instance of MaxPoolGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> MaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
+  public static <T extends TNumber> MaxPoolGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradV2", scope.makeOpName("MaxPoolGrad"));
-    opBuilder.addInput(origInput.asOutput());
-    opBuilder.addInput(origOutput.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(ksize.asOutput());
-    opBuilder.addInput(strides.asOutput());
+    opBuilder.addInput(origInput.asOutput(scope));
+    opBuilder.addInput(origOutput.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(ksize.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("padding", padding);
     if (options != null) {
@@ -113,7 +112,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 28547d8e884..14c933fc251 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGradGrad<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGradGrad<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradGrad}
@@ -75,13 +74,13 @@ private Options() {
    * @return a new instance of MaxPoolGradGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> MaxPoolGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
+  public static <T extends TNumber> MaxPoolGradGrad<T> create(Scope scope, Operand<T> origInput, Operand<T> origOutput, Operand<T> grad, Operand<TInt32> ksize, Operand<TInt32> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradGradV2", scope.makeOpName("MaxPoolGradGrad"));
-    opBuilder.addInput(origInput.asOutput());
-    opBuilder.addInput(origOutput.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(ksize.asOutput());
-    opBuilder.addInput(strides.asOutput());
+    opBuilder.addInput(origInput.asOutput(scope));
+    opBuilder.addInput(origOutput.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(ksize.asOutput(scope));
+    opBuilder.addInput(strides.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("padding", padding);
     if (options != null) {
@@ -113,7 +112,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5f170c69a4e..27a91c800ec 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -35,7 +34,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolGradGradWithArgmax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGradGradWithArgmax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradGradWithArgmax}
@@ -72,11 +71,11 @@ private Options() {
    * @return a new instance of MaxPoolGradGradWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolGradGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber, U extends TNumber> MaxPoolGradGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradGradWithArgmax", scope.makeOpName("MaxPoolGradGradWithArgmax"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(argmax.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(argmax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -114,7 +113,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c479a42d739..e7191c0a1e6 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class MaxPoolGradWithArgmax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class MaxPoolGradWithArgmax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolGradWithArgmax}
@@ -71,11 +70,11 @@ private Options() {
    * @return a new instance of MaxPoolGradWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber, U extends TNumber> MaxPoolGradWithArgmax<T> create(Scope scope, Operand<T> input, Operand<T> grad, Operand<U> argmax, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolGradWithArgmax", scope.makeOpName("MaxPoolGradWithArgmax"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(argmax.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(argmax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -113,7 +112,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 9928fa6e17e..983c9dd8d2b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -48,7 +47,7 @@
  * @param <U> data type for {@code argmax()} output
  */
 @Operator(group = "nn")
-public final class MaxPoolWithArgmax<T extends Tensor & TNumber, U extends Tensor & TNumber> extends RawOp {
+public final class MaxPoolWithArgmax<T extends TNumber, U extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.MaxPoolWithArgmax}
@@ -83,9 +82,9 @@ private Options() {
    * @return a new instance of MaxPoolWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolWithArgmax<T, U> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, DataType<U> Targmax, String padding, Options... options) {
+  public static <T extends TNumber, U extends TNumber> MaxPoolWithArgmax<T, U> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, DataType<U> Targmax, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MaxPoolWithArgmax", scope.makeOpName("MaxPoolWithArgmax"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
@@ -122,7 +121,7 @@ public static <T extends Tensor & TNumber, U extends Tensor & TNumber> MaxPoolWi
    * @return a new instance of MaxPoolWithArgmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> MaxPoolWithArgmax<T, TInt64> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
+  public static <T extends TNumber> MaxPoolWithArgmax<T, TInt64> create(Scope scope, Operand<T> input, List<Long> ksize, List<Long> strides, String padding, Options... options) {
     return create(scope, input, ksize, strides, TInt64.DTYPE, padding, options);
   }
   
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 2fc9ea59b4b..ccd2ccf7f35 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -43,7 +42,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "nn")
-public final class NthElement<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class NthElement<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.NthElement}
@@ -76,10 +75,10 @@ private Options() {
    * @return a new instance of NthElement
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> NthElement<T> create(Scope scope, Operand<T> input, Operand<TInt32> n, Options... options) {
+  public static <T extends TNumber> NthElement<T> create(Scope scope, Operand<T> input, Operand<TInt32> n, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("NthElement", scope.makeOpName("NthElement"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(n.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(n.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -107,7 +106,7 @@ public Output<T> values() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return values;
   }
   
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 e2f2a4b2764..1925a38f84a 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Produces the average pool of the input tensor for quantized types.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedAvgPool<T extends Tensor> extends RawOp {
+public final class QuantizedAvgPool<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedAvgPool operation.
@@ -52,11 +52,11 @@ public final class QuantizedAvgPool<T extends Tensor> extends RawOp {
    * @return a new instance of QuantizedAvgPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> QuantizedAvgPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
+  public static <T extends TType> QuantizedAvgPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedAvgPool", scope.makeOpName("QuantizedAvgPool"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
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 9d828d27e25..f2ebb87ab98 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Quantized Batch normalization.
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code result()} output
  */
 @Operator(group = "nn")
-public final class QuantizedBatchNormWithGlobalNormalization<U extends Tensor> extends RawOp {
+public final class QuantizedBatchNormWithGlobalNormalization<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedBatchNormWithGlobalNormalization operation.
@@ -73,23 +73,23 @@ public final class QuantizedBatchNormWithGlobalNormalization<U extends Tensor> e
    * @return a new instance of QuantizedBatchNormWithGlobalNormalization
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> QuantizedBatchNormWithGlobalNormalization<U> create(Scope scope, Operand<T> t, Operand<TFloat32> tMin, Operand<TFloat32> tMax, Operand<T> m, Operand<TFloat32> mMin, Operand<TFloat32> mMax, Operand<T> v, Operand<TFloat32> vMin, Operand<TFloat32> vMax, Operand<T> beta, Operand<TFloat32> betaMin, Operand<TFloat32> betaMax, Operand<T> gamma, Operand<TFloat32> gammaMin, Operand<TFloat32> gammaMax, DataType<U> outType, Float varianceEpsilon, Boolean scaleAfterNormalization) {
+  public static <U extends TType, T extends TType> QuantizedBatchNormWithGlobalNormalization<U> create(Scope scope, Operand<T> t, Operand<TFloat32> tMin, Operand<TFloat32> tMax, Operand<T> m, Operand<TFloat32> mMin, Operand<TFloat32> mMax, Operand<T> v, Operand<TFloat32> vMin, Operand<TFloat32> vMax, Operand<T> beta, Operand<TFloat32> betaMin, Operand<TFloat32> betaMax, Operand<T> gamma, Operand<TFloat32> gammaMin, Operand<TFloat32> gammaMax, DataType<U> outType, Float varianceEpsilon, Boolean scaleAfterNormalization) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedBatchNormWithGlobalNormalization", scope.makeOpName("QuantizedBatchNormWithGlobalNormalization"));
-    opBuilder.addInput(t.asOutput());
-    opBuilder.addInput(tMin.asOutput());
-    opBuilder.addInput(tMax.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(mMin.asOutput());
-    opBuilder.addInput(mMax.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(vMin.asOutput());
-    opBuilder.addInput(vMax.asOutput());
-    opBuilder.addInput(beta.asOutput());
-    opBuilder.addInput(betaMin.asOutput());
-    opBuilder.addInput(betaMax.asOutput());
-    opBuilder.addInput(gamma.asOutput());
-    opBuilder.addInput(gammaMin.asOutput());
-    opBuilder.addInput(gammaMax.asOutput());
+    opBuilder.addInput(t.asOutput(scope));
+    opBuilder.addInput(tMin.asOutput(scope));
+    opBuilder.addInput(tMax.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(mMin.asOutput(scope));
+    opBuilder.addInput(mMax.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(vMin.asOutput(scope));
+    opBuilder.addInput(vMax.asOutput(scope));
+    opBuilder.addInput(beta.asOutput(scope));
+    opBuilder.addInput(betaMin.asOutput(scope));
+    opBuilder.addInput(betaMax.asOutput(scope));
+    opBuilder.addInput(gamma.asOutput(scope));
+    opBuilder.addInput(gammaMin.asOutput(scope));
+    opBuilder.addInput(gammaMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     opBuilder.setAttr("variance_epsilon", varianceEpsilon);
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 5346b495296..a0da65f7195 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds Tensor 'bias' to Tensor 'input' for Quantized types.
@@ -37,7 +37,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedBiasAdd<V extends Tensor> extends RawOp {
+public final class QuantizedBiasAdd<V extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedBiasAdd operation.
@@ -53,14 +53,14 @@ public final class QuantizedBiasAdd<V extends Tensor> extends RawOp {
    * @return a new instance of QuantizedBiasAdd
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedBiasAdd<V> create(Scope scope, Operand<T> input, Operand<U> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minBias, Operand<TFloat32> maxBias, DataType<V> outType) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedBiasAdd<V> create(Scope scope, Operand<T> input, Operand<U> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minBias, Operand<TFloat32> maxBias, DataType<V> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedBiasAdd", scope.makeOpName("QuantizedBiasAdd"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minBias.asOutput());
-    opBuilder.addInput(maxBias.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minBias.asOutput(scope));
+    opBuilder.addInput(maxBias.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new QuantizedBiasAdd<V>(opBuilder.build());
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 073fbc605d5..5b44d96cdec 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndRelu<V extends Tensor> extends RawOp {
+public final class QuantizedConv2DAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndRelu}
@@ -80,14 +80,14 @@ private Options() {
    * @return a new instance of QuantizedConv2DAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DAndRelu", scope.makeOpName("QuantizedConv2DAndRelu"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 ebcaa853bd9..4562dbf0bb8 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndReluAndRequantize<V extends Tensor> extends RawOp {
+public final class QuantizedConv2DAndReluAndRequantize<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndReluAndRequantize}
@@ -82,16 +82,16 @@ private Options() {
    * @return a new instance of QuantizedConv2DAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DAndReluAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DAndReluAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DAndReluAndRequantize", scope.makeOpName("QuantizedConv2DAndReluAndRequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 4b1e3547259..27123a6918e 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DAndRequantize<V extends Tensor> extends RawOp {
+public final class QuantizedConv2DAndRequantize<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DAndRequantize}
@@ -82,16 +82,16 @@ private Options() {
    * @return a new instance of QuantizedConv2DAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DAndRequantize<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DAndRequantize", scope.makeOpName("QuantizedConv2DAndRequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 4eb5c4c0d8d..d330d96acac 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes QuantizedConv2D per channel.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DPerChannel<V extends Tensor> extends RawOp {
+public final class QuantizedConv2DPerChannel<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DPerChannel}
@@ -73,14 +73,14 @@ private Options() {
    * @return a new instance of QuantizedConv2DPerChannel
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DPerChannel<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DPerChannel<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DPerChannel", scope.makeOpName("QuantizedConv2DPerChannel"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 9c3e4469d2f..6a5da99645a 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBias<V extends Tensor> extends RawOp {
+public final class QuantizedConv2DWithBias<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBias}
@@ -81,15 +81,15 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBias
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBias", scope.makeOpName("QuantizedConv2DWithBias"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 d268bb0e2f9..189472dae67 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndRelu<V extends Tensor> extends RawOp {
+public final class QuantizedConv2DWithBiasAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndRelu}
@@ -81,15 +81,15 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasAndRelu", scope.makeOpName("QuantizedConv2DWithBiasAndRelu"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 287500aa5cf..2e6ffb88d2a 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndReluAndRequantize<W extends Tensor> extends RawOp {
+public final class QuantizedConv2DWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndReluAndRequantize}
@@ -83,17 +83,17 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
+  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasAndReluAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasAndReluAndRequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 226ec21d882..9c5728f2410 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasAndRequantize<W extends Tensor> extends RawOp {
+public final class QuantizedConv2DWithBiasAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasAndRequantize}
@@ -83,17 +83,17 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedConv2DWithBiasAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
+  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedConv2DWithBiasAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasAndRequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 0c79a3775ab..e691a6384f3 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <X> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X extends Tensor> extends RawOp {
+public final class QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSignedSumAndReluAndRequantize}
@@ -86,20 +86,20 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasSignedSumAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <X extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor, W extends Tensor> QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
+  public static <X extends TType, T extends TType, U extends TType, V extends TType, W extends TType> QuantizedConv2DWithBiasSignedSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
-    opBuilder.addInput(summand.asOutput());
-    opBuilder.addInput(minSummand.asOutput());
-    opBuilder.addInput(maxSummand.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
+    opBuilder.addInput(summand.asOutput(scope));
+    opBuilder.addInput(minSummand.asOutput(scope));
+    opBuilder.addInput(maxSummand.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 5bf9491abe5..034dcda53f4 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSumAndRelu<V extends Tensor> extends RawOp {
+public final class QuantizedConv2DWithBiasSumAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSumAndRelu}
@@ -82,16 +82,16 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasSumAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2DWithBiasSumAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> summand, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2DWithBiasSumAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> summand, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasSumAndRelu", scope.makeOpName("QuantizedConv2DWithBiasSumAndRelu"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(summand.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(summand.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 c0562b0ee30..89ef4bd6c74 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,17 +23,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <X> data type for {@code output()} output
  */
-public final class QuantizedConv2DWithBiasSumAndReluAndRequantize<X extends Tensor> extends RawOp {
+public final class QuantizedConv2DWithBiasSumAndReluAndRequantize<X extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2DWithBiasSumAndReluAndRequantize}
@@ -86,20 +86,20 @@ private Options() {
    * @return a new instance of QuantizedConv2DWithBiasSumAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <X extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor, W extends Tensor> QuantizedConv2DWithBiasSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
+  public static <X extends TType, T extends TType, U extends TType, V extends TType, W extends TType> QuantizedConv2DWithBiasSumAndReluAndRequantize<X> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, Operand<W> summand, Operand<TFloat32> minSummand, Operand<TFloat32> maxSummand, DataType<X> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2DWithBiasSumAndReluAndRequantize", scope.makeOpName("QuantizedConv2DWithBiasSumAndReluAndRequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
-    opBuilder.addInput(summand.asOutput());
-    opBuilder.addInput(minSummand.asOutput());
-    opBuilder.addInput(maxSummand.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
+    opBuilder.addInput(summand.asOutput(scope));
+    opBuilder.addInput(minSummand.asOutput(scope));
+    opBuilder.addInput(maxSummand.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 8f7a03b0bf0..2c126cf21b3 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes a 2D convolution given quantized 4D input and filter tensors.
@@ -41,7 +41,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedConv2d<V extends Tensor> extends RawOp {
+public final class QuantizedConv2d<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedConv2d}
@@ -84,14 +84,14 @@ private Options() {
    * @return a new instance of QuantizedConv2d
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedConv2d<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedConv2d<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConv2D", scope.makeOpName("QuantizedConv2d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 2ba5d7611ab..1e24089fd84 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2D<V extends Tensor> extends RawOp {
+public final class QuantizedDepthwiseConv2D<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2D}
@@ -73,14 +73,14 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2D
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedDepthwiseConv2D<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedDepthwiseConv2D<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2D", scope.makeOpName("QuantizedDepthwiseConv2D"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 b7aea60289a..cdd250b273c 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D with Bias.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBias<V extends Tensor> extends RawOp {
+public final class QuantizedDepthwiseConv2DWithBias<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBias}
@@ -74,15 +74,15 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2DWithBias
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedDepthwiseConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedDepthwiseConv2DWithBias<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2DWithBias", scope.makeOpName("QuantizedDepthwiseConv2DWithBias"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 3a0e049107e..53f8507cd5d 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D with Bias and Relu.
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBiasAndRelu<V extends Tensor> extends RawOp {
+public final class QuantizedDepthwiseConv2DWithBiasAndRelu<V extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBiasAndRelu}
@@ -83,15 +83,15 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2DWithBiasAndRelu
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor, T extends Tensor, U extends Tensor> QuantizedDepthwiseConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
+  public static <V extends TType, T extends TType, U extends TType> QuantizedDepthwiseConv2DWithBiasAndRelu<V> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<TFloat32> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, DataType<V> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2DWithBiasAndRelu", scope.makeOpName("QuantizedDepthwiseConv2DWithBiasAndRelu"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 57526c6554f..7bf7601bb12 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,19 +23,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes quantized depthwise Conv2D with Bias, Relu and Requantize.
  * 
  * @param <W> data type for {@code output()} output
  */
-public final class QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W extends Tensor> extends RawOp {
+public final class QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize}
@@ -85,17 +85,17 @@ private Options() {
    * @return a new instance of QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
+  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize<W> create(Scope scope, Operand<T> input, Operand<U> filter, Operand<V> bias, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, Operand<TFloat32> minFilter, Operand<TFloat32> maxFilter, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> outType, List<Long> strides, String padding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", scope.makeOpName("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(filter.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
-    opBuilder.addInput(minFilter.asOutput());
-    opBuilder.addInput(maxFilter.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(filter.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
+    opBuilder.addInput(minFilter.asOutput(scope));
+    opBuilder.addInput(maxFilter.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     long[] stridesArray = new long[strides.size()];
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 2f0fa6e14bb..ff7962047c0 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Quantized Instance normalization.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code y()} output
  */
 @Operator(group = "nn")
-public final class QuantizedInstanceNorm<T extends Tensor> extends RawOp {
+public final class QuantizedInstanceNorm<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.QuantizedInstanceNorm}
@@ -104,11 +104,11 @@ private Options() {
    * @return a new instance of QuantizedInstanceNorm
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> QuantizedInstanceNorm<T> create(Scope scope, Operand<T> x, Operand<TFloat32> xMin, Operand<TFloat32> xMax, Options... options) {
+  public static <T extends TType> QuantizedInstanceNorm<T> create(Scope scope, Operand<T> x, Operand<TFloat32> xMin, Operand<TFloat32> xMax, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedInstanceNorm", scope.makeOpName("QuantizedInstanceNorm"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(xMin.asOutput());
-    opBuilder.addInput(xMax.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(xMin.asOutput(scope));
+    opBuilder.addInput(xMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 3c60462ef7e..50aa58e8e8c 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Produces the max pool of the input tensor for quantized types.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class QuantizedMaxPool<T extends Tensor> extends RawOp {
+public final class QuantizedMaxPool<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedMaxPool operation.
@@ -52,11 +52,11 @@ public final class QuantizedMaxPool<T extends Tensor> extends RawOp {
    * @return a new instance of QuantizedMaxPool
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> QuantizedMaxPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
+  public static <T extends TType> QuantizedMaxPool<T> create(Scope scope, Operand<T> input, Operand<TFloat32> minInput, Operand<TFloat32> maxInput, List<Long> ksize, List<Long> strides, String padding) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMaxPool", scope.makeOpName("QuantizedMaxPool"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(minInput.asOutput());
-    opBuilder.addInput(maxInput.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(minInput.asOutput(scope));
+    opBuilder.addInput(maxInput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] ksizeArray = new long[ksize.size()];
     for (int i = 0; i < ksizeArray.length; ++i) {
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 a9c1db94a6a..e4627a46624 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes Quantized Rectified Linear: `max(features, 0)`
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedRelu<U extends Tensor> extends RawOp {
+public final class QuantizedRelu<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedRelu operation.
@@ -48,11 +48,11 @@ public final class QuantizedRelu<U extends Tensor> extends RawOp {
    * @return a new instance of QuantizedRelu
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> QuantizedRelu<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
+  public static <U extends TType, T extends TType> QuantizedRelu<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedRelu", scope.makeOpName("QuantizedRelu"));
-    opBuilder.addInput(features.asOutput());
-    opBuilder.addInput(minFeatures.asOutput());
-    opBuilder.addInput(maxFeatures.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
+    opBuilder.addInput(minFeatures.asOutput(scope));
+    opBuilder.addInput(maxFeatures.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new QuantizedRelu<U>(opBuilder.build());
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 8c617c5ed5e..f5c6681303e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedRelu6<U extends Tensor> extends RawOp {
+public final class QuantizedRelu6<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedRelu6 operation.
@@ -48,11 +48,11 @@ public final class QuantizedRelu6<U extends Tensor> extends RawOp {
    * @return a new instance of QuantizedRelu6
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> QuantizedRelu6<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
+  public static <U extends TType, T extends TType> QuantizedRelu6<U> create(Scope scope, Operand<T> features, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedRelu6", scope.makeOpName("QuantizedRelu6"));
-    opBuilder.addInput(features.asOutput());
-    opBuilder.addInput(minFeatures.asOutput());
-    opBuilder.addInput(maxFeatures.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
+    opBuilder.addInput(minFeatures.asOutput(scope));
+    opBuilder.addInput(maxFeatures.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new QuantizedRelu6<U>(opBuilder.build());
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 4a0431627de..d0206c217ed 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`
@@ -35,7 +35,7 @@
  * @param <U> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class QuantizedReluX<U extends Tensor> extends RawOp {
+public final class QuantizedReluX<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedReluX operation.
@@ -49,12 +49,12 @@ public final class QuantizedReluX<U extends Tensor> extends RawOp {
    * @return a new instance of QuantizedReluX
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> QuantizedReluX<U> create(Scope scope, Operand<T> features, Operand<TFloat32> maxValue, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
+  public static <U extends TType, T extends TType> QuantizedReluX<U> create(Scope scope, Operand<T> features, Operand<TFloat32> maxValue, Operand<TFloat32> minFeatures, Operand<TFloat32> maxFeatures, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedReluX", scope.makeOpName("QuantizedReluX"));
-    opBuilder.addInput(features.asOutput());
-    opBuilder.addInput(maxValue.asOutput());
-    opBuilder.addInput(minFeatures.asOutput());
-    opBuilder.addInput(maxFeatures.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
+    opBuilder.addInput(maxValue.asOutput(scope));
+    opBuilder.addInput(minFeatures.asOutput(scope));
+    opBuilder.addInput(maxFeatures.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new QuantizedReluX<U>(opBuilder.build());
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 6510aa66cfc..5bd78dc3483 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes rectified linear: `max(features, 0)`.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Relu<T extends Tensor> extends RawOp 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.
@@ -48,9 +48,9 @@ public final class Relu<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Relu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Relu<T> create(Scope scope, Operand<T> features) {
+  public static <T extends TType> Relu<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Relu", scope.makeOpName("Relu"));
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Relu<T>(opBuilder.build());
   }
@@ -62,7 +62,7 @@ public Output<T> activations() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return activations;
   }
   
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 f4003710db2..38433227a1e 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Relu6<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,9 +43,9 @@ public final class Relu6<T extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Relu6
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Relu6<T> create(Scope scope, Operand<T> features) {
+  public static <T extends TNumber> Relu6<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Relu6", scope.makeOpName("Relu6"));
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Relu6<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> activations() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return activations;
   }
   
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 e3b952604c1..e2dc6a92559 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class Relu6Grad<T extends Tensor & TNumber> extends RawOp 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.
@@ -45,10 +44,10 @@ public final class Relu6Grad<T extends Tensor & TNumber> extends RawOp implement
    * @return a new instance of Relu6Grad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Relu6Grad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends TNumber> Relu6Grad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Relu6Grad", scope.makeOpName("Relu6Grad"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Relu6Grad<T>(opBuilder.build());
   }
@@ -62,7 +61,7 @@ public Output<T> backprops() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return backprops;
   }
   
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 ab3a54f6d05..0881a584e28 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class ReluGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -45,10 +44,10 @@ public final class ReluGrad<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of ReluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends TNumber> ReluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReluGrad", scope.makeOpName("ReluGrad"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ReluGrad<T>(opBuilder.build());
   }
@@ -61,7 +60,7 @@ public Output<T> backprops() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return backprops;
   }
   
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 dc5ce9c8818..11770ffaff0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Selu<T extends Tensor & TNumber> extends RawOp 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.
@@ -52,9 +51,9 @@ public final class Selu<T extends Tensor & TNumber> extends RawOp implements Ope
    * @return a new instance of Selu
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Selu<T> create(Scope scope, Operand<T> features) {
+  public static <T extends TNumber> Selu<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Selu", scope.makeOpName("Selu"));
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Selu<T>(opBuilder.build());
   }
@@ -66,7 +65,7 @@ public Output<T> activations() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return activations;
   }
   
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 4f225f53e4f..ec41bd5f08d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SeluGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,10 +43,10 @@ public final class SeluGrad<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of SeluGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SeluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
+  public static <T extends TNumber> SeluGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> outputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("SeluGrad", scope.makeOpName("SeluGrad"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(outputs.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(outputs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SeluGrad<T>(opBuilder.build());
   }
@@ -61,7 +60,7 @@ public Output<T> backprops() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return backprops;
   }
   
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 1d8da60bc7f..113a5e97653 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code softmax()} output
  */
 @Operator(group = "nn")
-public final class Softmax<T extends Tensor & TNumber> extends RawOp 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.
@@ -48,9 +47,9 @@ public final class Softmax<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Softmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Softmax<T> create(Scope scope, Operand<T> logits) {
+  public static <T extends TNumber> Softmax<T> create(Scope scope, Operand<T> logits) {
     OperationBuilder opBuilder = scope.env().opBuilder("Softmax", scope.makeOpName("Softmax"));
-    opBuilder.addInput(logits.asOutput());
+    opBuilder.addInput(logits.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Softmax<T>(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<T> softmax() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return softmax;
   }
   
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 61a8bb03593..32e55c4f4ac 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -36,7 +35,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class SoftmaxCrossEntropyWithLogits<T extends Tensor & TNumber> extends RawOp {
+public final class SoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SoftmaxCrossEntropyWithLogits operation.
@@ -49,10 +48,10 @@ public final class SoftmaxCrossEntropyWithLogits<T extends Tensor & TNumber> ext
    * @return a new instance of SoftmaxCrossEntropyWithLogits
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<T> labels) {
+  public static <T extends TNumber> SoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<T> labels) {
     OperationBuilder opBuilder = scope.env().opBuilder("SoftmaxCrossEntropyWithLogits", scope.makeOpName("SoftmaxCrossEntropyWithLogits"));
-    opBuilder.addInput(features.asOutput());
-    opBuilder.addInput(labels.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
+    opBuilder.addInput(labels.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SoftmaxCrossEntropyWithLogits<T>(opBuilder.build());
   }
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 c40a7a5fb81..e2f2ad67766 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <T> data type for {@code activations()} output
  */
 @Operator(group = "nn")
-public final class Softsign<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,9 +43,9 @@ public final class Softsign<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Softsign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Softsign<T> create(Scope scope, Operand<T> features) {
+  public static <T extends TNumber> Softsign<T> create(Scope scope, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("Softsign", scope.makeOpName("Softsign"));
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Softsign<T>(opBuilder.build());
   }
@@ -58,7 +57,7 @@ public Output<T> activations() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return activations;
   }
   
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 5ec3babf609..69697df57f8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code backprops()} output
  */
-public final class SoftsignGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,10 +43,10 @@ public final class SoftsignGrad<T extends Tensor & TNumber> extends RawOp implem
    * @return a new instance of SoftsignGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SoftsignGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
+  public static <T extends TNumber> SoftsignGrad<T> create(Scope scope, Operand<T> gradients, Operand<T> features) {
     OperationBuilder opBuilder = scope.env().opBuilder("SoftsignGrad", scope.makeOpName("SoftsignGrad"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(features.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(features.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SoftsignGrad<T>(opBuilder.build());
   }
@@ -60,7 +59,7 @@ public Output<T> backprops() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return backprops;
   }
   
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 32fe3d007ac..34cacde78bf 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * SpaceToBatch for 4-D tensors of type T.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class SpaceToBatch<T extends Tensor> extends RawOp 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.
@@ -122,10 +122,10 @@ public final class SpaceToBatch<T extends Tensor> extends RawOp implements Opera
    * @return a new instance of SpaceToBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SpaceToBatch<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Long blockSize) {
+  public static <T extends TType, U extends TNumber> SpaceToBatch<T> create(Scope scope, Operand<T> input, Operand<U> paddings, Long blockSize) {
     OperationBuilder opBuilder = scope.env().opBuilder("SpaceToBatch", scope.makeOpName("SpaceToBatch"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(paddings.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(paddings.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("block_size", blockSize);
     return new SpaceToBatch<T>(opBuilder.build());
@@ -138,7 +138,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 b3c0f27a374..3f5459a95ec 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * SpaceToDepth for tensors of type T.
@@ -107,7 +107,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "nn")
-public final class SpaceToDepth<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SpaceToDepth<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.SpaceToDepth}
@@ -138,9 +138,9 @@ private Options() {
    * @return a new instance of SpaceToDepth
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SpaceToDepth<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
+  public static <T extends TType> SpaceToDepth<T> create(Scope scope, Operand<T> input, Long blockSize, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SpaceToDepth", scope.makeOpName("SpaceToDepth"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("block_size", blockSize);
     if (options != null) {
@@ -167,7 +167,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 9ddb57134df..0c62793e97e 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -41,7 +40,7 @@
  * @param <T> data type for {@code loss()} output
  */
 @Operator(group = "nn")
-public final class SparseSoftmaxCrossEntropyWithLogits<T extends Tensor & TNumber> extends RawOp {
+public final class SparseSoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSoftmaxCrossEntropyWithLogits operation.
@@ -53,10 +52,10 @@ public final class SparseSoftmaxCrossEntropyWithLogits<T extends Tensor & TNumbe
    * @return a new instance of SparseSoftmaxCrossEntropyWithLogits
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<U> labels) {
+  public static <T extends TNumber, U extends TNumber> SparseSoftmaxCrossEntropyWithLogits<T> create(Scope scope, Operand<T> features, Operand<U> labels) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSoftmaxCrossEntropyWithLogits", scope.makeOpName("SparseSoftmaxCrossEntropyWithLogits"));
-    opBuilder.addInput(features.asOutput());
-    opBuilder.addInput(labels.asOutput());
+    opBuilder.addInput(features.asOutput(scope));
+    opBuilder.addInput(labels.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSoftmaxCrossEntropyWithLogits<T>(opBuilder.build());
   }
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 a14beb011c1..9713c85511c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -46,7 +45,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "nn")
-public final class TopK<T extends Tensor & TNumber> extends RawOp {
+public final class TopK<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.nn.TopK}
@@ -79,10 +78,10 @@ private Options() {
    * @return a new instance of TopK
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> TopK<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Options... options) {
+  public static <T extends TNumber> TopK<T> create(Scope scope, Operand<T> input, Operand<TInt32> k, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TopKV2", scope.makeOpName("TopK"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(k.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(k.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 660da0d22ea..d03ee3f81f0 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
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Dequantize the 'input' tensor into a float or bfloat16 Tensor.
@@ -85,7 +85,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Dequantize<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class Dequantize<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.Dequantize}
@@ -137,11 +137,11 @@ private Options() {
    * @return a new instance of Dequantize
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Dequantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<U> dtype, Options... options) {
+  public static <U extends TNumber, T extends TType> Dequantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Dequantize", scope.makeOpName("Dequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(minRange.asOutput());
-    opBuilder.addInput(maxRange.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(minRange.asOutput(scope));
+    opBuilder.addInput(maxRange.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -171,7 +171,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Dequantize<U> creat
    * @return a new instance of Dequantize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Dequantize<TFloat32> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, Options... options) {
+  public static <T extends TType> Dequantize<TFloat32> create(Scope scope, Operand<T> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, Options... options) {
     return create(scope, input, minRange, maxRange, TFloat32.DTYPE, options);
   }
   
@@ -203,7 +203,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 16ea096ef9d..e3a0933e421 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
@@ -107,7 +107,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static FakeQuantWithMinMaxArgs create(Scope scope, Operand<TFloat32> inputs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FakeQuantWithMinMaxArgs", scope.makeOpName("FakeQuantWithMinMaxArgs"));
-    opBuilder.addInput(inputs.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -163,7 +163,7 @@ public Output<TFloat32> outputs() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return outputs;
   }
   
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 71da232b5df..5baaea8d666 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
@@ -91,8 +91,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static FakeQuantWithMinMaxArgsGradient create(Scope scope, Operand<TFloat32> gradients, Operand<TFloat32> inputs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FakeQuantWithMinMaxArgsGradient", scope.makeOpName("FakeQuantWithMinMaxArgsGradient"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(inputs.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(inputs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -150,7 +150,7 @@ public Output<TFloat32> backprops() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return backprops;
   }
   
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 21113c6a6f3..1538e109fe3 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
@@ -94,9 +94,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static FakeQuantWithMinMaxVars create(Scope scope, Operand<TFloat32> inputs, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FakeQuantWithMinMaxVars", scope.makeOpName("FakeQuantWithMinMaxVars"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(min.asOutput());
-    opBuilder.addInput(max.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(min.asOutput(scope));
+    opBuilder.addInput(max.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -132,7 +132,7 @@ public Output<TFloat32> outputs() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return outputs;
   }
   
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 7b4e10d9c21..bdcc9865c8e 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
@@ -76,10 +76,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static FakeQuantWithMinMaxVarsGradient create(Scope scope, Operand<TFloat32> gradients, Operand<TFloat32> inputs, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FakeQuantWithMinMaxVarsGradient", scope.makeOpName("FakeQuantWithMinMaxVarsGradient"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(min.asOutput());
-    opBuilder.addInput(max.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(min.asOutput(scope));
+    opBuilder.addInput(max.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 1302ae47b32..f10f351809d 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
@@ -95,9 +95,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static FakeQuantWithMinMaxVarsPerChannel create(Scope scope, Operand<TFloat32> inputs, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FakeQuantWithMinMaxVarsPerChannel", scope.makeOpName("FakeQuantWithMinMaxVarsPerChannel"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(min.asOutput());
-    opBuilder.addInput(max.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(min.asOutput(scope));
+    opBuilder.addInput(max.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -133,7 +133,7 @@ public Output<TFloat32> outputs() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return outputs;
   }
   
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 3e104c42c90..05fc3abad29 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
@@ -78,10 +78,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static FakeQuantWithMinMaxVarsPerChannelGradient create(Scope scope, Operand<TFloat32> gradients, Operand<TFloat32> inputs, Operand<TFloat32> min, Operand<TFloat32> max, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("FakeQuantWithMinMaxVarsPerChannelGradient", scope.makeOpName("FakeQuantWithMinMaxVarsPerChannelGradient"));
-    opBuilder.addInput(gradients.asOutput());
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(min.asOutput());
-    opBuilder.addInput(max.asOutput());
+    opBuilder.addInput(gradients.asOutput(scope));
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(min.asOutput(scope));
+    opBuilder.addInput(max.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 0eca716f70c..57a5ab0f982 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Quantize the 'input' tensor of type float to 'output' tensor of type 'T'.
@@ -145,7 +145,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Quantize<T extends Tensor> extends RawOp {
+public final class Quantize<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.Quantize}
@@ -220,11 +220,11 @@ private Options() {
    * @return a new instance of Quantize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Quantize<T> create(Scope scope, Operand<TFloat32> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<T> T, Options... options) {
+  public static <T extends TType> Quantize<T> create(Scope scope, Operand<TFloat32> input, Operand<TFloat32> minRange, Operand<TFloat32> maxRange, DataType<T> T, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizeV2", scope.makeOpName("Quantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(minRange.asOutput());
-    opBuilder.addInput(maxRange.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(minRange.asOutput(scope));
+    opBuilder.addInput(maxRange.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("T", T);
     if (options != null) {
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 5e8d3799c03..33ca9d35e4e 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizeAndDequantize<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class QuantizeAndDequantize<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.QuantizeAndDequantize}
@@ -98,12 +97,12 @@ private Options() {
    * @return a new instance of QuantizeAndDequantize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> QuantizeAndDequantize<T> create(Scope scope, Operand<T> input, Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits, Options... options) {
+  public static <T extends TNumber> QuantizeAndDequantize<T> create(Scope scope, Operand<T> input, Operand<T> inputMin, Operand<T> inputMax, Operand<TInt32> numBits, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizeAndDequantizeV3", scope.makeOpName("QuantizeAndDequantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputMin.asOutput());
-    opBuilder.addInput(inputMax.asOutput());
-    opBuilder.addInput(numBits.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputMin.asOutput(scope));
+    opBuilder.addInput(inputMax.asOutput(scope));
+    opBuilder.addInput(numBits.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -159,7 +158,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 4cebed52421..478396f2cb4 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Convert the quantized 'input' tensor into a lower-precision 'output', using the
@@ -58,7 +58,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizeDownAndShrinkRange<U extends Tensor> extends RawOp {
+public final class QuantizeDownAndShrinkRange<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizeDownAndShrinkRange operation.
@@ -71,11 +71,11 @@ public final class QuantizeDownAndShrinkRange<U extends Tensor> extends RawOp {
    * @return a new instance of QuantizeDownAndShrinkRange
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> QuantizeDownAndShrinkRange<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, DataType<U> outType) {
+  public static <U extends TType, T extends TType> QuantizeDownAndShrinkRange<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizeDownAndShrinkRange", scope.makeOpName("QuantizeDownAndShrinkRange"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputMin.asOutput());
-    opBuilder.addInput(inputMax.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputMin.asOutput(scope));
+    opBuilder.addInput(inputMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new QuantizeDownAndShrinkRange<U>(opBuilder.build());
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 332f2101bee..26749ca5034 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
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -29,6 +28,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates quantized tensors along one dimension.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class QuantizedConcat<T extends Tensor> extends RawOp {
+public final class QuantizedConcat<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new QuantizedConcat operation.
@@ -51,12 +51,12 @@ public final class QuantizedConcat<T extends Tensor> extends RawOp {
    * @return a new instance of QuantizedConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> QuantizedConcat<T> create(Scope scope, Operand<TInt32> concatDim, Iterable<Operand<T>> values, Iterable<Operand<TFloat32>> inputMins, Iterable<Operand<TFloat32>> inputMaxes) {
+  public static <T extends TType> QuantizedConcat<T> create(Scope scope, Operand<TInt32> concatDim, Iterable<Operand<T>> values, Iterable<Operand<TFloat32>> inputMins, Iterable<Operand<TFloat32>> inputMaxes) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedConcat", scope.makeOpName("QuantizedConcat"));
-    opBuilder.addInput(concatDim.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(values));
-    opBuilder.addInputList(Operands.asOutputs(inputMins));
-    opBuilder.addInputList(Operands.asOutputs(inputMaxes));
+    opBuilder.addInput(concatDim.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputMins));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputMaxes));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new QuantizedConcat<T>(opBuilder.build());
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java
index 3644fbad609..94585c41fd5 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndDequantize.java
@@ -22,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndDequantize<W extends Tensor & TNumber> extends RawOp implements Operand<W> {
+public final class QuantizedMatMulWithBiasAndDequantize<W extends TNumber> extends RawOp implements Operand<W> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.QuantizedMatMulWithBiasAndDequantize}
@@ -90,17 +90,17 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndDequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor & TNumber, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBiasAndDequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
+  public static <W extends TNumber, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBiasAndDequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndDequantize", scope.makeOpName("QuantizedMatMulWithBiasAndDequantize"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minA.asOutput());
-    opBuilder.addInput(maxA.asOutput());
-    opBuilder.addInput(minB.asOutput());
-    opBuilder.addInput(maxB.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minA.asOutput(scope));
+    opBuilder.addInput(maxA.asOutput(scope));
+    opBuilder.addInput(minB.asOutput(scope));
+    opBuilder.addInput(maxB.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     if (options != null) {
@@ -147,7 +147,7 @@ public Output<W> out() {
   }
   
   @Override
-  public Output<W> asOutput() {
+  public Output<W> asOutput(Scope scope) {
     return out;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java
index a20f936928b..fda6c7cc98a 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/quantization/QuantizedMatMulWithBiasAndRequantize.java
@@ -22,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * @param <W> data type for {@code out()} output
  */
-public final class QuantizedMatMulWithBiasAndRequantize<W extends Tensor> extends RawOp {
+public final class QuantizedMatMulWithBiasAndRequantize<W extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.quantization.QuantizedMatMulWithBiasAndRequantize}
@@ -89,17 +89,17 @@ private Options() {
    * @return a new instance of QuantizedMatMulWithBiasAndRequantize
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor, T extends Tensor, U extends Tensor, V extends Tensor> QuantizedMatMulWithBiasAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
+  public static <W extends TType, T extends TType, U extends TType, V extends TType> QuantizedMatMulWithBiasAndRequantize<W> create(Scope scope, Operand<T> a, Operand<U> b, Operand<V> bias, Operand<TFloat32> minA, Operand<TFloat32> maxA, Operand<TFloat32> minB, Operand<TFloat32> maxB, Operand<TFloat32> minFreezedOutput, Operand<TFloat32> maxFreezedOutput, DataType<W> Toutput, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("QuantizedMatMulWithBiasAndRequantize", scope.makeOpName("QuantizedMatMulWithBiasAndRequantize"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
-    opBuilder.addInput(bias.asOutput());
-    opBuilder.addInput(minA.asOutput());
-    opBuilder.addInput(maxA.asOutput());
-    opBuilder.addInput(minB.asOutput());
-    opBuilder.addInput(maxB.asOutput());
-    opBuilder.addInput(minFreezedOutput.asOutput());
-    opBuilder.addInput(maxFreezedOutput.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
+    opBuilder.addInput(bias.asOutput(scope));
+    opBuilder.addInput(minA.asOutput(scope));
+    opBuilder.addInput(maxA.asOutput(scope));
+    opBuilder.addInput(minB.asOutput(scope));
+    opBuilder.addInput(maxB.asOutput(scope));
+    opBuilder.addInput(minFreezedOutput.asOutput(scope));
+    opBuilder.addInput(maxFreezedOutput.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Toutput", Toutput);
     if (options != null) {
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 22424b45998..897d42c511c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes a range that covers the actual values present in a quantized tensor.
@@ -49,11 +49,11 @@ public final class RequantizationRange extends RawOp {
    * @return a new instance of RequantizationRange
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RequantizationRange create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
+  public static <T extends TType> RequantizationRange create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax) {
     OperationBuilder opBuilder = scope.env().opBuilder("RequantizationRange", scope.makeOpName("RequantizationRange"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputMin.asOutput());
-    opBuilder.addInput(inputMax.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputMin.asOutput(scope));
+    opBuilder.addInput(inputMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RequantizationRange(opBuilder.build());
   }
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 a7fcd8f68fa..aad9a358285 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts the quantized `input` tensor into a lower-precision `output`.
@@ -43,7 +43,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "quantization")
-public final class Requantize<U extends Tensor> extends RawOp {
+public final class Requantize<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Requantize operation.
@@ -58,13 +58,13 @@ public final class Requantize<U extends Tensor> extends RawOp {
    * @return a new instance of Requantize
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> Requantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
+  public static <U extends TType, T extends TType> Requantize<U> create(Scope scope, Operand<T> input, Operand<TFloat32> inputMin, Operand<TFloat32> inputMax, Operand<TFloat32> requestedOutputMin, Operand<TFloat32> requestedOutputMax, DataType<U> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("Requantize", scope.makeOpName("Requantize"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(inputMin.asOutput());
-    opBuilder.addInput(inputMax.asOutput());
-    opBuilder.addInput(requestedOutputMin.asOutput());
-    opBuilder.addInput(requestedOutputMax.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(inputMin.asOutput(scope));
+    opBuilder.addInput(inputMax.asOutput(scope));
+    opBuilder.addInput(requestedOutputMin.asOutput(scope));
+    opBuilder.addInput(requestedOutputMax.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new Requantize<U>(opBuilder.build());
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 5187a14f018..74263034667 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
@@ -23,13 +23,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Gather ragged slices from `params` axis `0` according to `indices`.
@@ -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 Tensor & TNumber, U extends Tensor> extends RawOp {
+public final class RaggedGather<T extends TNumber, U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedGather operation.
@@ -84,11 +84,11 @@ public final class RaggedGather<T extends Tensor & TNumber, U extends Tensor> ex
    * @return a new instance of RaggedGather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor, V extends Tensor & TNumber> RaggedGather<T, U> create(Scope scope, Iterable<Operand<T>> paramsNestedSplits, Operand<U> paramsDenseValues, Operand<V> indices, Long OUTPUTRAGGEDRANK) {
+  public static <T extends TNumber, U extends TType, V extends TNumber> RaggedGather<T, U> create(Scope scope, Iterable<Operand<T>> paramsNestedSplits, Operand<U> paramsDenseValues, Operand<V> indices, Long OUTPUTRAGGEDRANK) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedGather", scope.makeOpName("RaggedGather"));
-    opBuilder.addInputList(Operands.asOutputs(paramsNestedSplits));
-    opBuilder.addInput(paramsDenseValues.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, paramsNestedSplits));
+    opBuilder.addInput(paramsDenseValues.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("OUTPUT_RAGGED_RANK", OUTPUTRAGGEDRANK);
     return new RaggedGather<T, U>(opBuilder.build());
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 eb384c652e7..9d443530a9a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -51,7 +50,7 @@
  * @param <U> data type for {@code rtNestedSplits()} output
  * @param <T> data type for {@code rtDenseValues()} output
  */
-public final class RaggedRange<U extends Tensor & TNumber, T extends Tensor & TNumber> extends RawOp {
+public final class RaggedRange<U extends TNumber, T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedRange operation.
@@ -64,11 +63,11 @@ public final class RaggedRange<U extends Tensor & TNumber, T extends Tensor & TN
    * @return a new instance of RaggedRange
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RaggedRange<U, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas, DataType<U> Tsplits) {
+  public static <U extends TNumber, T extends TNumber> RaggedRange<U, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas, DataType<U> Tsplits) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedRange", scope.makeOpName("RaggedRange"));
-    opBuilder.addInput(starts.asOutput());
-    opBuilder.addInput(limits.asOutput());
-    opBuilder.addInput(deltas.asOutput());
+    opBuilder.addInput(starts.asOutput(scope));
+    opBuilder.addInput(limits.asOutput(scope));
+    opBuilder.addInput(deltas.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tsplits", Tsplits);
     return new RaggedRange<U, T>(opBuilder.build());
@@ -84,7 +83,7 @@ public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RaggedRan
    * @return a new instance of RaggedRange
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> RaggedRange<TInt64, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas) {
+  public static <T extends TNumber> RaggedRange<TInt64, T> create(Scope scope, Operand<T> starts, Operand<T> limits, Operand<T> deltas) {
     return create(scope, starts, limits, deltas, TInt64.DTYPE);
   }
   
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 eb9e9cb0edd..38c9a31033f 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,13 +24,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Decodes a `variant` Tensor into a `RaggedTensor`.
@@ -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 Tensor & TNumber, T extends Tensor> extends RawOp {
+public final class RaggedTensorFromVariant<U extends TNumber, T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorFromVariant operation.
@@ -67,9 +67,9 @@ public final class RaggedTensorFromVariant<U extends Tensor & TNumber, T extends
    * @return a new instance of RaggedTensorFromVariant
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> RaggedTensorFromVariant<U, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues, DataType<U> Tsplits) {
+  public static <U extends TNumber, T extends TType> RaggedTensorFromVariant<U, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues, DataType<U> Tsplits) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorFromVariant", scope.makeOpName("RaggedTensorFromVariant"));
-    opBuilder.addInput(encodedRagged.asOutput());
+    opBuilder.addInput(encodedRagged.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("input_ragged_rank", inputRaggedRank);
     opBuilder.setAttr("output_ragged_rank", outputRaggedRank);
@@ -91,7 +91,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> RaggedTensorFromVar
    * @return a new instance of RaggedTensorFromVariant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RaggedTensorFromVariant<TInt64, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues) {
+  public static <T extends TType> RaggedTensorFromVariant<TInt64, T> create(Scope scope, Operand<?> encodedRagged, Long inputRaggedRank, Long outputRaggedRank, DataType<T> Tvalues) {
     return create(scope, encodedRagged, inputRaggedRank, outputRaggedRank, Tvalues, TInt64.DTYPE);
   }
   
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 7021e3204b6..e3b956562e8 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
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -29,6 +28,7 @@
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts a `RaggedTensor` into a `SparseTensor` with the same values.
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code sparseValues()} output
  */
-public final class RaggedTensorToSparse<U extends Tensor> extends RawOp {
+public final class RaggedTensorToSparse<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToSparse operation.
@@ -50,10 +50,10 @@ public final class RaggedTensorToSparse<U extends Tensor> extends RawOp {
    * @return a new instance of RaggedTensorToSparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> RaggedTensorToSparse<U> create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues) {
+  public static <U extends TType, T extends TNumber> RaggedTensorToSparse<U> create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorToSparse", scope.makeOpName("RaggedTensorToSparse"));
-    opBuilder.addInputList(Operands.asOutputs(rtNestedSplits));
-    opBuilder.addInput(rtDenseValues.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, rtNestedSplits));
+    opBuilder.addInput(rtDenseValues.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RaggedTensorToSparse<U>(opBuilder.build());
   }
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 04854bca2e3..6f482ed1898 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
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Create a dense tensor from a ragged tensor, possibly altering its shape.
@@ -58,7 +58,7 @@
  * 
  * @param <U> data type for {@code result()} output
  */
-public final class RaggedTensorToTensor<U extends Tensor> extends RawOp 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.
@@ -106,12 +106,12 @@ public final class RaggedTensorToTensor<U extends Tensor> extends RawOp implemen
    * @return a new instance of RaggedTensorToTensor
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber, V extends Tensor & TNumber> RaggedTensorToTensor<U> create(Scope scope, Operand<T> shape, Operand<U> values, Operand<U> defaultValue, Iterable<Operand<V>> rowPartitionTensors, List<String> rowPartitionTypes) {
+  public static <U extends TType, T extends TNumber, V extends TNumber> RaggedTensorToTensor<U> create(Scope scope, Operand<T> shape, Operand<U> values, Operand<U> defaultValue, Iterable<Operand<V>> rowPartitionTensors, List<String> rowPartitionTypes) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorToTensor", scope.makeOpName("RaggedTensorToTensor"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(values.asOutput());
-    opBuilder.addInput(defaultValue.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(rowPartitionTensors));
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
+    opBuilder.addInput(defaultValue.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, rowPartitionTensors));
     opBuilder = scope.applyControlDependencies(opBuilder);
     String[] rowPartitionTypesArray = new String[rowPartitionTypes.size()];
     for (int i = 0; i < rowPartitionTypesArray.length; ++i) {
@@ -129,7 +129,7 @@ public Output<U> result() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return result;
   }
   
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 b97f50aa371..13eb61054f4 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Encodes a `RaggedTensor` into a `variant` Tensor.
@@ -45,7 +45,7 @@
  * corresponding decoding logic.
  * 
  */
-public final class RaggedTensorToVariant extends RawOp implements Operand<Tensor> {
+public final class RaggedTensorToVariant extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new RaggedTensorToVariant operation.
@@ -58,10 +58,10 @@ public final class RaggedTensorToVariant extends RawOp implements Operand<Tensor
    * @return a new instance of RaggedTensorToVariant
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> RaggedTensorToVariant create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues, Boolean batchedInput) {
+  public static <T extends TNumber, U extends TType> RaggedTensorToVariant create(Scope scope, Iterable<Operand<T>> rtNestedSplits, Operand<U> rtDenseValues, Boolean batchedInput) {
     OperationBuilder opBuilder = scope.env().opBuilder("RaggedTensorToVariant", scope.makeOpName("RaggedTensorToVariant"));
-    opBuilder.addInputList(Operands.asOutputs(rtNestedSplits));
-    opBuilder.addInput(rtDenseValues.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, rtNestedSplits));
+    opBuilder.addInput(rtDenseValues.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("batched_input", batchedInput);
     return new RaggedTensorToVariant(opBuilder.build());
@@ -76,8 +76,8 @@ public Output<?> encodedRagged() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) encodedRagged;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) encodedRagged;
   }
   
   private Output<?> encodedRagged;
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 1fca347c024..fc49c35a18c 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
@@ -91,7 +91,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static AllCandidateSampler create(Scope scope, Operand<TInt64> trueClasses, Long numTrue, Long numSampled, Boolean unique, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AllCandidateSampler", scope.makeOpName("AllCandidateSampler"));
-    opBuilder.addInput(trueClasses.asOutput());
+    opBuilder.addInput(trueClasses.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_true", numTrue);
     opBuilder.setAttr("num_sampled", numSampled);
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 f0d6d9d77cd..5bfca5e0ff9 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
@@ -42,8 +42,8 @@ public final class AnonymousRandomSeedGenerator extends RawOp {
   @Endpoint(describeByClass = true)
   public static AnonymousRandomSeedGenerator create(Scope scope, Operand<TInt64> seed, Operand<TInt64> seed2) {
     OperationBuilder opBuilder = scope.env().opBuilder("AnonymousRandomSeedGenerator", scope.makeOpName("AnonymousRandomSeedGenerator"));
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(seed2.asOutput());
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(seed2.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AnonymousRandomSeedGenerator(opBuilder.build());
   }
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 63e2698983b..8a0b9f0d7e0 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
@@ -40,8 +40,8 @@ public final class DeleteRandomSeedGenerator extends RawOp {
   @Endpoint(describeByClass = true)
   public static DeleteRandomSeedGenerator create(Scope scope, Operand<?> handle, Operand<?> deleter) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeleteRandomSeedGenerator", scope.makeOpName("DeleteRandomSeedGenerator"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(deleter.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(deleter.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DeleteRandomSeedGenerator(opBuilder.build());
   }
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 8295f36e678..b3b2e630bf3 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
@@ -92,7 +92,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LogUniformCandidateSampler create(Scope scope, Operand<TInt64> trueClasses, Long numTrue, Long numSampled, Boolean unique, Long rangeMax, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LogUniformCandidateSampler", scope.makeOpName("LogUniformCandidateSampler"));
-    opBuilder.addInput(trueClasses.asOutput());
+    opBuilder.addInput(trueClasses.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_true", numTrue);
     opBuilder.setAttr("num_sampled", numSampled);
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 9dc925b6a67..75cfd2900cb 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class Multinomial<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class Multinomial<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.Multinomial}
@@ -80,10 +79,10 @@ private Options() {
    * @return a new instance of Multinomial
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> Multinomial<U> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, DataType<U> outputDtype, Options... options) {
+  public static <U extends TNumber, T extends TNumber> Multinomial<U> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, DataType<U> outputDtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Multinomial", scope.makeOpName("Multinomial"));
-    opBuilder.addInput(logits.asOutput());
-    opBuilder.addInput(numSamples.asOutput());
+    opBuilder.addInput(logits.asOutput(scope));
+    opBuilder.addInput(numSamples.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_dtype", outputDtype);
     if (options != null) {
@@ -110,7 +109,7 @@ public static <U extends Tensor & TNumber, T extends Tensor & TNumber> Multinomi
    * @return a new instance of Multinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Multinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Options... options) {
+  public static <T extends TNumber> Multinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Options... options) {
     return create(scope, logits, numSamples, TInt64.DTYPE, options);
   }
   
@@ -138,7 +137,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 bfb4d78034f..23e49766805 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Non-deterministically generates some integers.
@@ -36,7 +36,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class NonDeterministicInts<U extends Tensor> extends RawOp 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.
@@ -47,9 +47,9 @@ public final class NonDeterministicInts<U extends Tensor> extends RawOp implemen
    * @return a new instance of NonDeterministicInts
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> NonDeterministicInts<U> create(Scope scope, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends TType, T extends TType> NonDeterministicInts<U> create(Scope scope, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("NonDeterministicInts", scope.makeOpName("NonDeterministicInts"));
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new NonDeterministicInts<U>(opBuilder.build());
@@ -63,7 +63,7 @@ public static <U extends Tensor, T extends Tensor> NonDeterministicInts<U> creat
    * @return a new instance of NonDeterministicInts
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> NonDeterministicInts<TInt64> create(Scope scope, Operand<T> shape) {
+  public static <T extends TType> NonDeterministicInts<TInt64> create(Scope scope, Operand<T> shape) {
     return create(scope, shape, TInt64.DTYPE);
   }
   
@@ -75,7 +75,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 e8bf7f6c2c0..9684b99c585 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class ParameterizedTruncatedNormal<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class ParameterizedTruncatedNormal<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.ParameterizedTruncatedNormal}
@@ -83,13 +82,13 @@ private Options() {
    * @return a new instance of ParameterizedTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> ParameterizedTruncatedNormal<U> create(Scope scope, Operand<T> shape, Operand<U> means, Operand<U> stdevs, Operand<U> minvals, Operand<U> maxvals, Options... options) {
+  public static <U extends TNumber, T extends TNumber> ParameterizedTruncatedNormal<U> create(Scope scope, Operand<T> shape, Operand<U> means, Operand<U> stdevs, Operand<U> minvals, Operand<U> maxvals, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ParameterizedTruncatedNormal", scope.makeOpName("ParameterizedTruncatedNormal"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(means.asOutput());
-    opBuilder.addInput(stdevs.asOutput());
-    opBuilder.addInput(minvals.asOutput());
-    opBuilder.addInput(maxvals.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(means.asOutput(scope));
+    opBuilder.addInput(stdevs.asOutput(scope));
+    opBuilder.addInput(minvals.asOutput(scope));
+    opBuilder.addInput(maxvals.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -129,7 +128,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 68e01c497bf..1bd796016d8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomGamma<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class RandomGamma<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomGamma}
@@ -82,10 +81,10 @@ private Options() {
    * @return a new instance of RandomGamma
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomGamma<U> create(Scope scope, Operand<T> shape, Operand<U> alpha, Options... options) {
+  public static <U extends TNumber, T extends TNumber> RandomGamma<U> create(Scope scope, Operand<T> shape, Operand<U> alpha, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomGamma", scope.makeOpName("RandomGamma"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(alpha.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -126,7 +125,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 da6f9f8d291..edaf34bb4a8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -33,7 +32,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class RandomGammaGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -44,10 +43,10 @@ public final class RandomGammaGrad<T extends Tensor & TNumber> extends RawOp imp
    * @return a new instance of RandomGammaGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> RandomGammaGrad<T> create(Scope scope, Operand<T> alpha, Operand<T> sample) {
+  public static <T extends TNumber> RandomGammaGrad<T> create(Scope scope, Operand<T> alpha, Operand<T> sample) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomGammaGrad", scope.makeOpName("RandomGammaGrad"));
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(sample.asOutput());
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(sample.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RandomGammaGrad<T>(opBuilder.build());
   }
@@ -59,7 +58,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 dc788f9cfa3..aa4a2c830d8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -46,7 +45,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomPoisson<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
+public final class RandomPoisson<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomPoisson}
@@ -91,10 +90,10 @@ private Options() {
    * @return a new instance of RandomPoisson
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<V> create(Scope scope, Operand<T> shape, Operand<U> rate, DataType<V> dtype, Options... options) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> RandomPoisson<V> create(Scope scope, Operand<T> shape, Operand<U> rate, DataType<V> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomPoissonV2", scope.makeOpName("RandomPoisson"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(rate.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(rate.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -122,7 +121,7 @@ public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends
    * @return a new instance of RandomPoisson
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> RandomPoisson<TInt64> create(Scope scope, Operand<T> shape, Operand<U> rate, Options... options) {
+  public static <T extends TNumber, U extends TNumber> RandomPoisson<TInt64> create(Scope scope, Operand<T> shape, Operand<U> rate, Options... options) {
     return create(scope, shape, rate, TInt64.DTYPE, options);
   }
   
@@ -152,7 +151,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 c31c6541e7f..c89287c5bca 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Randomly shuffles a tensor along its first dimension.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomShuffle<T extends Tensor> extends RawOp implements Operand<T> {
+public final class RandomShuffle<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomShuffle}
@@ -84,9 +84,9 @@ private Options() {
    * @return a new instance of RandomShuffle
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RandomShuffle<T> create(Scope scope, Operand<T> value, Options... options) {
+  public static <T extends TType> RandomShuffle<T> create(Scope scope, Operand<T> value, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomShuffle", scope.makeOpName("RandomShuffle"));
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -126,7 +126,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 6ea9e5633e6..10c03656d56 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomStandardNormal<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class RandomStandardNormal<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomStandardNormal}
@@ -79,9 +78,9 @@ private Options() {
    * @return a new instance of RandomStandardNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomStandardNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
+  public static <U extends TNumber, T extends TNumber> RandomStandardNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomStandardNormal", scope.makeOpName("RandomStandardNormal"));
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -121,7 +120,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 a920775fb4d..e49185d39ee 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomUniform<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class RandomUniform<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomUniform}
@@ -80,9 +79,9 @@ private Options() {
    * @return a new instance of RandomUniform
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniform<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
+  public static <U extends TNumber, T extends TNumber> RandomUniform<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomUniform", scope.makeOpName("RandomUniform"));
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -122,7 +121,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 08f8e4b9143..e0b5661074c 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class RandomUniformInt<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class RandomUniformInt<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.RandomUniformInt}
@@ -85,11 +84,11 @@ private Options() {
    * @return a new instance of RandomUniformInt
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> RandomUniformInt<U> create(Scope scope, Operand<T> shape, Operand<U> minval, Operand<U> maxval, Options... options) {
+  public static <U extends TNumber, T extends TNumber> RandomUniformInt<U> create(Scope scope, Operand<T> shape, Operand<U> minval, Operand<U> maxval, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RandomUniformInt", scope.makeOpName("RandomUniformInt"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(minval.asOutput());
-    opBuilder.addInput(maxval.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(minval.asOutput(scope));
+    opBuilder.addInput(maxval.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -128,7 +127,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 a8520fc1144..a52942cad7a 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
@@ -189,7 +189,7 @@ public Output<TString> records() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return records;
   }
   
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 af9e90226b4..2cae7e498ca 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
@@ -48,9 +48,9 @@ public final class RngSkip extends RawOp {
   @Endpoint(describeByClass = true)
   public static RngSkip create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<TInt64> delta) {
     OperationBuilder opBuilder = scope.env().opBuilder("RngSkip", scope.makeOpName("RngSkip"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(algorithm.asOutput());
-    opBuilder.addInput(delta.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(algorithm.asOutput(scope));
+    opBuilder.addInput(delta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RngSkip(opBuilder.build());
   }
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 6514b4ac268..37e5c464717 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -34,7 +33,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatefulRandomBinomial<V extends Tensor & TNumber> extends RawOp 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.
@@ -49,13 +48,13 @@ public final class StatefulRandomBinomial<V extends Tensor & TNumber> extends Ra
    * @return a new instance of StatefulRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<V> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs, DataType<V> dtype) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatefulRandomBinomial<V> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulRandomBinomial", scope.makeOpName("StatefulRandomBinomial"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(algorithm.asOutput());
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(counts.asOutput());
-    opBuilder.addInput(probs.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(algorithm.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(counts.asOutput(scope));
+    opBuilder.addInput(probs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatefulRandomBinomial<V>(opBuilder.build());
@@ -73,7 +72,7 @@ public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends
    * @return a new instance of StatefulRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatefulRandomBinomial<TInt64> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs) {
+  public static <T extends TNumber, U extends TNumber> StatefulRandomBinomial<TInt64> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> counts, Operand<U> probs) {
     return create(scope, resource, algorithm, shape, counts, probs, TInt64.DTYPE);
   }
   
@@ -84,7 +83,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 e8f769af15d..dbcf454051a 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a normal distribution.
@@ -38,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatefulStandardNormal<U extends Tensor> extends RawOp 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.
@@ -51,11 +51,11 @@ public final class StatefulStandardNormal<U extends Tensor> extends RawOp implem
    * @return a new instance of StatefulStandardNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> StatefulStandardNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends TType, T extends TType> StatefulStandardNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulStandardNormalV2", scope.makeOpName("StatefulStandardNormal"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(algorithm.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(algorithm.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatefulStandardNormal<U>(opBuilder.build());
@@ -71,7 +71,7 @@ public static <U extends Tensor, T extends Tensor> StatefulStandardNormal<U> cre
    * @return a new instance of StatefulStandardNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> StatefulStandardNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
+  public static <T extends TType> StatefulStandardNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return create(scope, resource, algorithm, shape, TFloat32.DTYPE);
   }
   
@@ -83,7 +83,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 99324e10c84..aa925a9ca3c 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a truncated normal distribution.
@@ -39,7 +39,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulTruncatedNormal<U extends Tensor> extends RawOp 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.
@@ -52,11 +52,11 @@ public final class StatefulTruncatedNormal<U extends Tensor> extends RawOp imple
    * @return a new instance of StatefulTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> StatefulTruncatedNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends TType, T extends TType> StatefulTruncatedNormal<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulTruncatedNormal", scope.makeOpName("StatefulTruncatedNormal"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(algorithm.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(algorithm.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatefulTruncatedNormal<U>(opBuilder.build());
@@ -72,7 +72,7 @@ public static <U extends Tensor, T extends Tensor> StatefulTruncatedNormal<U> cr
    * @return a new instance of StatefulTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> StatefulTruncatedNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
+  public static <T extends TType> StatefulTruncatedNormal<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return create(scope, resource, algorithm, shape, TFloat32.DTYPE);
   }
   
@@ -84,7 +84,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 67f68909be6..f3a3b0dc1fe 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random values from a uniform distribution.
@@ -38,7 +38,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniform<U extends Tensor> extends RawOp 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.
@@ -51,11 +51,11 @@ public final class StatefulUniform<U extends Tensor> extends RawOp implements Op
    * @return a new instance of StatefulUniform
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> StatefulUniform<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends TType, T extends TType> StatefulUniform<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulUniform", scope.makeOpName("StatefulUniform"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(algorithm.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(algorithm.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatefulUniform<U>(opBuilder.build());
@@ -71,7 +71,7 @@ public static <U extends Tensor, T extends Tensor> StatefulUniform<U> create(Sco
    * @return a new instance of StatefulUniform
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> StatefulUniform<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
+  public static <T extends TType> StatefulUniform<TFloat32> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape) {
     return create(scope, resource, algorithm, shape, TFloat32.DTYPE);
   }
   
@@ -83,7 +83,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 6f6cae38905..1c4faec2584 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random integers from a uniform distribution.
@@ -36,7 +36,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniformFullInt<U extends Tensor> extends RawOp 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.
@@ -49,11 +49,11 @@ public final class StatefulUniformFullInt<U extends Tensor> extends RawOp implem
    * @return a new instance of StatefulUniformFullInt
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> StatefulUniformFullInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
+  public static <U extends TType, T extends TType> StatefulUniformFullInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulUniformFullInt", scope.makeOpName("StatefulUniformFullInt"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(algorithm.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(algorithm.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatefulUniformFullInt<U>(opBuilder.build());
@@ -67,7 +67,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 11026bf281a..fede4acc47a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs random integers from a uniform distribution.
@@ -41,7 +41,7 @@
  * 
  * @param <U> data type for {@code output()} output
  */
-public final class StatefulUniformInt<U extends Tensor> extends RawOp 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.
@@ -55,13 +55,13 @@ public final class StatefulUniformInt<U extends Tensor> extends RawOp implements
    * @return a new instance of StatefulUniformInt
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> StatefulUniformInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> minval, Operand<U> maxval) {
+  public static <U extends TType, T extends TType> StatefulUniformInt<U> create(Scope scope, Operand<?> resource, Operand<TInt64> algorithm, Operand<T> shape, Operand<U> minval, Operand<U> maxval) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatefulUniformInt", scope.makeOpName("StatefulUniformInt"));
-    opBuilder.addInput(resource.asOutput());
-    opBuilder.addInput(algorithm.asOutput());
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(minval.asOutput());
-    opBuilder.addInput(maxval.asOutput());
+    opBuilder.addInput(resource.asOutput(scope));
+    opBuilder.addInput(algorithm.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(minval.asOutput(scope));
+    opBuilder.addInput(maxval.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new StatefulUniformInt<U>(opBuilder.build());
   }
@@ -74,7 +74,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 86b2956deac..61850f95914 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessMultinomial<V extends Tensor & TNumber> extends RawOp 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.
@@ -51,11 +50,11 @@ public final class StatelessMultinomial<V extends Tensor & TNumber> extends RawO
    * @return a new instance of StatelessMultinomial
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<V> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed, DataType<V> outputDtype) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessMultinomial<V> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed, DataType<V> outputDtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessMultinomial", scope.makeOpName("StatelessMultinomial"));
-    opBuilder.addInput(logits.asOutput());
-    opBuilder.addInput(numSamples.asOutput());
-    opBuilder.addInput(seed.asOutput());
+    opBuilder.addInput(logits.asOutput(scope));
+    opBuilder.addInput(numSamples.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_dtype", outputDtype);
     return new StatelessMultinomial<V>(opBuilder.build());
@@ -72,7 +71,7 @@ public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends
    * @return a new instance of StatelessMultinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessMultinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed) {
+  public static <T extends TNumber, U extends TNumber> StatelessMultinomial<TInt64> create(Scope scope, Operand<T> logits, Operand<TInt32> numSamples, Operand<U> seed) {
     return create(scope, logits, numSamples, seed, TInt64.DTYPE);
   }
   
@@ -85,7 +84,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java
index 7101fd58126..2f2221ac05c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomBinomial.java
@@ -22,7 +22,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * 
  * @param <W> data type for {@code output()} output
  */
-public final class StatelessRandomBinomial<W extends Tensor & TNumber> extends RawOp implements Operand<W> {
+public final class StatelessRandomBinomial<W extends TNumber> extends RawOp implements Operand<W> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomBinomial operation.
@@ -55,12 +54,12 @@ public final class StatelessRandomBinomial<W extends Tensor & TNumber> extends R
    * @return a new instance of StatelessRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> StatelessRandomBinomial<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs, DataType<W> dtype) {
+  public static <W extends TNumber, T extends TNumber, U extends TNumber, V extends TNumber> StatelessRandomBinomial<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs, DataType<W> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomBinomial", scope.makeOpName("StatelessRandomBinomial"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(counts.asOutput());
-    opBuilder.addInput(probs.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(counts.asOutput(scope));
+    opBuilder.addInput(probs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatelessRandomBinomial<W>(opBuilder.build());
@@ -79,7 +78,7 @@ public static <W extends Tensor & TNumber, T extends Tensor & TNumber, U extends
    * @return a new instance of StatelessRandomBinomial
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> StatelessRandomBinomial<TInt64> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> StatelessRandomBinomial<TInt64> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> counts, Operand<V> probs) {
     return create(scope, shape, seed, counts, probs, TInt64.DTYPE);
   }
   
@@ -91,7 +90,7 @@ public Output<W> output() {
   }
   
   @Override
-  public Output<W> asOutput() {
+  public Output<W> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java
index e4668fe6503..9fb3dc3e27d 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomGamma.java
@@ -21,7 +21,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class StatelessRandomGamma<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
+public final class StatelessRandomGamma<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomGamma operation.
@@ -50,11 +49,11 @@ public final class StatelessRandomGamma<V extends Tensor & TNumber> extends RawO
    * @return a new instance of StatelessRandomGamma
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomGamma<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> alpha) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomGamma<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> alpha) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomGammaV2", scope.makeOpName("StatelessRandomGamma"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(alpha.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new StatelessRandomGamma<V>(opBuilder.build());
   }
@@ -67,7 +66,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 02c0aa5ea69..8b4089796f2 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessRandomNormal<V extends Tensor & TNumber> extends RawOp 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.
@@ -52,10 +51,10 @@ public final class StatelessRandomNormal<V extends Tensor & TNumber> extends Raw
    * @return a new instance of StatelessRandomNormal
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomNormal", scope.makeOpName("StatelessRandomNormal"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatelessRandomNormal<V>(opBuilder.build());
@@ -70,7 +69,7 @@ public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends
    * @return a new instance of StatelessRandomNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
+  public static <T extends TNumber, U extends TNumber> StatelessRandomNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
     return create(scope, shape, seed, TFloat32.DTYPE);
   }
   
@@ -82,7 +81,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java
index 6908af2d5df..3540bf11dc8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomPoisson.java
@@ -22,7 +22,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * 
  * @param <W> data type for {@code output()} output
  */
-public final class StatelessRandomPoisson<W extends Tensor & TNumber> extends RawOp implements Operand<W> {
+public final class StatelessRandomPoisson<W extends TNumber> extends RawOp implements Operand<W> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomPoisson operation.
@@ -52,11 +51,11 @@ public final class StatelessRandomPoisson<W extends Tensor & TNumber> extends Ra
    * @return a new instance of StatelessRandomPoisson
    */
   @Endpoint(describeByClass = true)
-  public static <W extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> StatelessRandomPoisson<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> lam, DataType<W> dtype) {
+  public static <W extends TNumber, T extends TNumber, U extends TNumber, V extends TNumber> StatelessRandomPoisson<W> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> lam, DataType<W> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomPoisson", scope.makeOpName("StatelessRandomPoisson"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(lam.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(lam.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatelessRandomPoisson<W>(opBuilder.build());
@@ -70,7 +69,7 @@ public Output<W> output() {
   }
   
   @Override
-  public Output<W> asOutput() {
+  public Output<W> asOutput(Scope scope) {
     return output;
   }
   
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 ac7e814a03f..54a7d37a0f8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -41,7 +40,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessRandomUniform<V extends Tensor & TNumber> extends RawOp 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.
@@ -53,10 +52,10 @@ public final class StatelessRandomUniform<V extends Tensor & TNumber> extends Ra
    * @return a new instance of StatelessRandomUniform
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniform<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomUniform", scope.makeOpName("StatelessRandomUniform"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatelessRandomUniform<V>(opBuilder.build());
@@ -71,7 +70,7 @@ public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends
    * @return a new instance of StatelessRandomUniform
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniform<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
+  public static <T extends TNumber, U extends TNumber> StatelessRandomUniform<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
     return create(scope, shape, seed, TFloat32.DTYPE);
   }
   
@@ -83,7 +82,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java
index 20d68c68b8a..185d542b16c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/random/StatelessRandomUniformFullInt.java
@@ -22,7 +22,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class StatelessRandomUniformFullInt<V extends Tensor & TNumber> extends RawOp implements Operand<V> {
+public final class StatelessRandomUniformFullInt<V extends TNumber> extends RawOp implements Operand<V> {
   
   /**
    * Factory method to create a class wrapping a new StatelessRandomUniformFullInt operation.
@@ -50,10 +49,10 @@ public final class StatelessRandomUniformFullInt<V extends Tensor & TNumber> ext
    * @return a new instance of StatelessRandomUniformFullInt
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniformFullInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniformFullInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomUniformFullInt", scope.makeOpName("StatelessRandomUniformFullInt"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatelessRandomUniformFullInt<V>(opBuilder.build());
@@ -67,7 +66,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 302364dcda1..f5e43c706f0 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * 
  * @param <V> data type for {@code output()} output
  */
-public final class StatelessRandomUniformInt<V extends Tensor & TNumber> extends RawOp 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.
@@ -50,12 +49,12 @@ public final class StatelessRandomUniformInt<V extends Tensor & TNumber> extends
    * @return a new instance of StatelessRandomUniformInt
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessRandomUniformInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> minval, Operand<V> maxval) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessRandomUniformInt<V> create(Scope scope, Operand<T> shape, Operand<U> seed, Operand<V> minval, Operand<V> maxval) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessRandomUniformInt", scope.makeOpName("StatelessRandomUniformInt"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
-    opBuilder.addInput(minval.asOutput());
-    opBuilder.addInput(maxval.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
+    opBuilder.addInput(minval.asOutput(scope));
+    opBuilder.addInput(maxval.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new StatelessRandomUniformInt<V>(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 4e411a0e918..79fabada2e5 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <V> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class StatelessTruncatedNormal<V extends Tensor & TNumber> extends RawOp 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.
@@ -54,10 +53,10 @@ public final class StatelessTruncatedNormal<V extends Tensor & TNumber> extends
    * @return a new instance of StatelessTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
+  public static <V extends TNumber, T extends TNumber, U extends TNumber> StatelessTruncatedNormal<V> create(Scope scope, Operand<T> shape, Operand<U> seed, DataType<V> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatelessTruncatedNormal", scope.makeOpName("StatelessTruncatedNormal"));
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(seed.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(seed.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new StatelessTruncatedNormal<V>(opBuilder.build());
@@ -72,7 +71,7 @@ public static <V extends Tensor & TNumber, T extends Tensor & TNumber, U extends
    * @return a new instance of StatelessTruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> StatelessTruncatedNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
+  public static <T extends TNumber, U extends TNumber> StatelessTruncatedNormal<TFloat32> create(Scope scope, Operand<T> shape, Operand<U> seed) {
     return create(scope, shape, seed, TFloat32.DTYPE);
   }
   
@@ -84,7 +83,7 @@ public Output<V> output() {
   }
   
   @Override
-  public Output<V> asOutput() {
+  public Output<V> asOutput(Scope scope) {
     return output;
   }
   
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 e18fe049a44..8da2e8d668d 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -39,7 +38,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "random")
-public final class TruncatedNormal<U extends Tensor & TNumber> extends RawOp implements Operand<U> {
+public final class TruncatedNormal<U extends TNumber> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.random.TruncatedNormal}
@@ -81,9 +80,9 @@ private Options() {
    * @return a new instance of TruncatedNormal
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor & TNumber> TruncatedNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
+  public static <U extends TNumber, T extends TNumber> TruncatedNormal<U> create(Scope scope, Operand<T> shape, DataType<U> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TruncatedNormal", scope.makeOpName("TruncatedNormal"));
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
@@ -124,7 +123,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 e568dd965ba..e382e9e706d 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
@@ -92,7 +92,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static UniformCandidateSampler create(Scope scope, Operand<TInt64> trueClasses, Long numTrue, Long numSampled, Boolean unique, Long rangeMax, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UniformCandidateSampler", scope.makeOpName("UniformCandidateSampler"));
-    opBuilder.addInput(trueClasses.asOutput());
+    opBuilder.addInput(trueClasses.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_true", numTrue);
     opBuilder.setAttr("num_sampled", numSampled);
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 2a02cb822ff..c4f222adddc 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft extends RawOp implements Operand<Tensor> {
+public final class BatchFft extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft operation.
@@ -42,7 +42,7 @@ public final class BatchFft extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static BatchFft create(Scope scope, Operand<?> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchFFT", scope.makeOpName("BatchFft"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchFft(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 c3c7f41d95c..e2bfa248cda 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft2d extends RawOp implements Operand<Tensor> {
+public final class BatchFft2d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft2d operation.
@@ -42,7 +42,7 @@ public final class BatchFft2d extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static BatchFft2d create(Scope scope, Operand<?> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchFFT2D", scope.makeOpName("BatchFft2d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchFft2d(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 2b410eb46c6..c6d3d989c97 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchFft3d extends RawOp implements Operand<Tensor> {
+public final class BatchFft3d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchFft3d operation.
@@ -42,7 +42,7 @@ public final class BatchFft3d extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static BatchFft3d create(Scope scope, Operand<?> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchFFT3D", scope.makeOpName("BatchFft3d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchFft3d(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 dc39ac5eb87..dec3c5e960e 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft extends RawOp implements Operand<Tensor> {
+public final class BatchIfft extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft operation.
@@ -42,7 +42,7 @@ public final class BatchIfft extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static BatchIfft create(Scope scope, Operand<?> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchIFFT", scope.makeOpName("BatchIfft"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchIfft(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 b65861e69f5..201fdb8d20d 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft2d extends RawOp implements Operand<Tensor> {
+public final class BatchIfft2d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft2d operation.
@@ -42,7 +42,7 @@ public final class BatchIfft2d extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static BatchIfft2d create(Scope scope, Operand<?> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchIFFT2D", scope.makeOpName("BatchIfft2d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchIfft2d(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 37273cc46d1..916cee2da49 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,16 +21,16 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
 @Operator(group = "signal")
-public final class BatchIfft3d extends RawOp implements Operand<Tensor> {
+public final class BatchIfft3d extends RawOp implements Operand<TType> {
   
   /**
    * Factory method to create a class wrapping a new BatchIfft3d operation.
@@ -42,7 +42,7 @@ public final class BatchIfft3d extends RawOp implements Operand<Tensor> {
   @Endpoint(describeByClass = true)
   public static BatchIfft3d create(Scope scope, Operand<?> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchIFFT3D", scope.makeOpName("BatchIfft3d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BatchIfft3d(opBuilder.build());
   }
@@ -55,8 +55,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 c1f55022c88..9b3b360d382 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class Fft<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Fft
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Fft<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Fft<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("FFT", scope.makeOpName("Fft"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Fft<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 e068214f761..fb6073d2703 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * 2D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft2d<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class Fft2d<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Fft2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Fft2d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Fft2d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("FFT2D", scope.makeOpName("Fft2d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Fft2d<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 94acb912f81..832fc8ef836 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * 3D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Fft3d<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class Fft3d<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Fft3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Fft3d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Fft3d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("FFT3D", scope.makeOpName("Fft3d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Fft3d<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 8e2d5d51da7..e3725fdf53a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Inverse fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class Ifft<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Ifft
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Ifft<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Ifft<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("IFFT", scope.makeOpName("Ifft"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Ifft<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 b2337eee6d4..9b2886e0eaf 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 2D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft2d<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class Ifft2d<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Ifft2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Ifft2d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Ifft2d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("IFFT2D", scope.makeOpName("Ifft2d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Ifft2d<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 6cb44533fe5..db1d67e1be5 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 3D fast Fourier transform.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Ifft3d<T extends Tensor> extends RawOp 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.
@@ -46,9 +46,9 @@ public final class Ifft3d<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Ifft3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Ifft3d<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Ifft3d<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("IFFT3D", scope.makeOpName("Ifft3d"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Ifft3d<T>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 f0b2000b323..587c979daf7 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -30,6 +29,7 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Inverse real-valued fast Fourier transform.
@@ -51,7 +51,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft<U extends Tensor & TNumber> extends RawOp 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.
@@ -63,10 +63,10 @@ public final class Irfft<U extends Tensor & TNumber> extends RawOp implements Op
    * @return a new instance of Irfft
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Irfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
+  public static <U extends TNumber, T extends TType> Irfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
     OperationBuilder opBuilder = scope.env().opBuilder("IRFFT", scope.makeOpName("Irfft"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(fftLength.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(fftLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Treal", Treal);
     return new Irfft<U>(opBuilder.build());
@@ -81,7 +81,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Irfft<U> create(Sco
    * @return a new instance of Irfft
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Irfft<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
+  public static <T extends TType> Irfft<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
     return create(scope, input, fftLength, TFloat32.DTYPE);
   }
   
@@ -99,7 +99,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 47adf7d8d44..a237feb23e3 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -30,6 +29,7 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 2D real-valued fast Fourier transform.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft2d<U extends Tensor & TNumber> extends RawOp 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.
@@ -64,10 +64,10 @@ public final class Irfft2d<U extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Irfft2d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Irfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
+  public static <U extends TNumber, T extends TType> Irfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
     OperationBuilder opBuilder = scope.env().opBuilder("IRFFT2D", scope.makeOpName("Irfft2d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(fftLength.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(fftLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Treal", Treal);
     return new Irfft2d<U>(opBuilder.build());
@@ -82,7 +82,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Irfft2d<U> create(S
    * @return a new instance of Irfft2d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Irfft2d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
+  public static <T extends TType> Irfft2d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
     return create(scope, input, fftLength, TFloat32.DTYPE);
   }
   
@@ -100,7 +100,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 bc8a1ded733..6c64db377cb 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -30,6 +29,7 @@
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Inverse 3D real-valued fast Fourier transform.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Irfft3d<U extends Tensor & TNumber> extends RawOp 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.
@@ -64,10 +64,10 @@ public final class Irfft3d<U extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of Irfft3d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor & TNumber, T extends Tensor> Irfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
+  public static <U extends TNumber, T extends TType> Irfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Treal) {
     OperationBuilder opBuilder = scope.env().opBuilder("IRFFT3D", scope.makeOpName("Irfft3d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(fftLength.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(fftLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Treal", Treal);
     return new Irfft3d<U>(opBuilder.build());
@@ -82,7 +82,7 @@ public static <U extends Tensor & TNumber, T extends Tensor> Irfft3d<U> create(S
    * @return a new instance of Irfft3d
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Irfft3d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
+  public static <T extends TType> Irfft3d<TFloat32> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength) {
     return create(scope, input, fftLength, TFloat32.DTYPE);
   }
   
@@ -100,7 +100,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 345d72c0180..45a41ac241f 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Real-valued fast Fourier transform.
@@ -47,7 +47,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft<U extends Tensor> extends RawOp 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.
@@ -59,10 +59,10 @@ public final class Rfft<U extends Tensor> extends RawOp implements Operand<U> {
    * @return a new instance of Rfft
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> Rfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
+  public static <U extends TType, T extends TNumber> Rfft<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     OperationBuilder opBuilder = scope.env().opBuilder("RFFT", scope.makeOpName("Rfft"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(fftLength.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(fftLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tcomplex", Tcomplex);
     return new Rfft<U>(opBuilder.build());
@@ -82,7 +82,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 d614088de46..ce4ebed8a77 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * 2D real-valued fast Fourier transform.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft2d<U extends Tensor> extends RawOp 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.
@@ -60,10 +60,10 @@ public final class Rfft2d<U extends Tensor> extends RawOp implements Operand<U>
    * @return a new instance of Rfft2d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> Rfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
+  public static <U extends TType, T extends TNumber> Rfft2d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     OperationBuilder opBuilder = scope.env().opBuilder("RFFT2D", scope.makeOpName("Rfft2d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(fftLength.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(fftLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tcomplex", Tcomplex);
     return new Rfft2d<U>(opBuilder.build());
@@ -84,7 +84,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 3bf003c64c3..839fa58028c 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * 3D real-valued fast Fourier transform.
@@ -48,7 +48,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "signal")
-public final class Rfft3d<U extends Tensor> extends RawOp 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.
@@ -60,10 +60,10 @@ public final class Rfft3d<U extends Tensor> extends RawOp implements Operand<U>
    * @return a new instance of Rfft3d
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> Rfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
+  public static <U extends TType, T extends TNumber> Rfft3d<U> create(Scope scope, Operand<T> input, Operand<TInt32> fftLength, DataType<U> Tcomplex) {
     OperationBuilder opBuilder = scope.env().opBuilder("RFFT3D", scope.makeOpName("Rfft3d"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(fftLength.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(fftLength.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("Tcomplex", Tcomplex);
     return new Rfft3d<U>(opBuilder.build());
@@ -84,7 +84,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 8e9d9e28eda..1ded309957c 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles.
@@ -98,11 +98,11 @@ private Options() {
    * @return a new instance of AddManySparseToTensorsMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AddManySparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
+  public static <T extends TType> AddManySparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AddManySparseToTensorsMap", scope.makeOpName("AddManySparseToTensorsMap"));
-    opBuilder.addInput(sparseIndices.asOutput());
-    opBuilder.addInput(sparseValues.asOutput());
-    opBuilder.addInput(sparseShape.asOutput());
+    opBuilder.addInput(sparseIndices.asOutput(scope));
+    opBuilder.addInput(sparseValues.asOutput(scope));
+    opBuilder.addInput(sparseShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -141,7 +141,7 @@ public Output<TInt64> sparseHandles() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return sparseHandles;
   }
   
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 edfdd9def6e..3265408d552 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Add a `SparseTensor` to a `SparseTensorsMap` return its handle.
@@ -89,11 +89,11 @@ private Options() {
    * @return a new instance of AddSparseToTensorsMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AddSparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
+  public static <T extends TType> AddSparseToTensorsMap create(Scope scope, Operand<TInt64> sparseIndices, Operand<T> sparseValues, Operand<TInt64> sparseShape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AddSparseToTensorsMap", scope.makeOpName("AddSparseToTensorsMap"));
-    opBuilder.addInput(sparseIndices.asOutput());
-    opBuilder.addInput(sparseValues.asOutput());
-    opBuilder.addInput(sparseShape.asOutput());
+    opBuilder.addInput(sparseIndices.asOutput(scope));
+    opBuilder.addInput(sparseValues.asOutput(scope));
+    opBuilder.addInput(sparseShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -132,7 +132,7 @@ public Output<TInt64> sparseHandle() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return sparseHandle;
   }
   
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 2fdb4a05901..b001495ab42 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies set operation along last dimension of 2 `Tensor` inputs.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class DenseToDenseSetOperation<T extends Tensor> extends RawOp {
+public final class DenseToDenseSetOperation<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.DenseToDenseSetOperation}
@@ -76,10 +76,10 @@ private Options() {
    * @return a new instance of DenseToDenseSetOperation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DenseToDenseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<T> set2, String setOperation, Options... options) {
+  public static <T extends TType> DenseToDenseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<T> set2, String setOperation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DenseToDenseSetOperation", scope.makeOpName("DenseToDenseSetOperation"));
-    opBuilder.addInput(set1.asOutput());
-    opBuilder.addInput(set2.asOutput());
+    opBuilder.addInput(set1.asOutput(scope));
+    opBuilder.addInput(set2.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("set_operation", setOperation);
     if (options != null) {
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 65a2d153214..177125fcf9e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies set operation along last dimension of `Tensor` and `SparseTensor`.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class DenseToSparseSetOperation<T extends Tensor> extends RawOp {
+public final class DenseToSparseSetOperation<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.DenseToSparseSetOperation}
@@ -89,12 +89,12 @@ private Options() {
    * @return a new instance of DenseToSparseSetOperation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> DenseToSparseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
+  public static <T extends TType> DenseToSparseSetOperation<T> create(Scope scope, Operand<T> set1, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("DenseToSparseSetOperation", scope.makeOpName("DenseToSparseSetOperation"));
-    opBuilder.addInput(set1.asOutput());
-    opBuilder.addInput(set2Indices.asOutput());
-    opBuilder.addInput(set2Values.asOutput());
-    opBuilder.addInput(set2Shape.asOutput());
+    opBuilder.addInput(set1.asOutput(scope));
+    opBuilder.addInput(set2Indices.asOutput(scope));
+    opBuilder.addInput(set2Values.asOutput(scope));
+    opBuilder.addInput(set2Shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("set_operation", setOperation);
     if (options != null) {
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 ec19524753b..2b82232ee93 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Deserialize `SparseTensor` objects.
@@ -77,7 +77,7 @@
  * @param <U> data type for {@code sparseValues()} output
  */
 @Operator(group = "sparse")
-public final class DeserializeSparse<U extends Tensor> extends RawOp {
+public final class DeserializeSparse<U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new DeserializeSparse operation.
@@ -89,9 +89,9 @@ public final class DeserializeSparse<U extends Tensor> extends RawOp {
    * @return a new instance of DeserializeSparse
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor> DeserializeSparse<U> create(Scope scope, Operand<T> serializedSparse, DataType<U> dtype) {
+  public static <U extends TType, T extends TType> DeserializeSparse<U> create(Scope scope, Operand<T> serializedSparse, DataType<U> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("DeserializeSparse", scope.makeOpName("DeserializeSparse"));
-    opBuilder.addInput(serializedSparse.asOutput());
+    opBuilder.addInput(serializedSparse.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new DeserializeSparse<U>(opBuilder.build());
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 e85002cd92d..8f4c3548ff5 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies a sparse gradient to a given accumulator.
@@ -54,13 +54,13 @@ public final class SparseAccumulatorApplyGradient extends RawOp {
    * @return a new instance of SparseAccumulatorApplyGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseAccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<TInt64> gradientIndices, Operand<T> gradientValues, Operand<TInt64> gradientShape, Boolean hasKnownShape) {
+  public static <T extends TType> SparseAccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<TInt64> gradientIndices, Operand<T> gradientValues, Operand<TInt64> gradientShape, Boolean hasKnownShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAccumulatorApplyGradient", scope.makeOpName("SparseAccumulatorApplyGradient"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(localStep.asOutput());
-    opBuilder.addInput(gradientIndices.asOutput());
-    opBuilder.addInput(gradientValues.asOutput());
-    opBuilder.addInput(gradientShape.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(localStep.asOutput(scope));
+    opBuilder.addInput(gradientIndices.asOutput(scope));
+    opBuilder.addInput(gradientValues.asOutput(scope));
+    opBuilder.addInput(gradientShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("has_known_shape", hasKnownShape);
     return new SparseAccumulatorApplyGradient(opBuilder.build());
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 0d360cd8647..1641efc864f 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -30,6 +29,7 @@
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Extracts the average sparse gradient in a SparseConditionalAccumulator.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code values()} output
  */
 @Operator(group = "sparse")
-public final class SparseAccumulatorTakeGradient<T extends Tensor> extends RawOp {
+public final class SparseAccumulatorTakeGradient<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAccumulatorTakeGradient operation.
@@ -57,10 +57,10 @@ public final class SparseAccumulatorTakeGradient<T extends Tensor> extends RawOp
    * @return a new instance of SparseAccumulatorTakeGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseAccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
+  public static <T extends TType> SparseAccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAccumulatorTakeGradient", scope.makeOpName("SparseAccumulatorTakeGradient"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(numRequired.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(numRequired.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new SparseAccumulatorTakeGradient<T>(opBuilder.build());
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 2f9db91cf41..6fcc524f6ba 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds two `SparseTensor` objects to produce another `SparseTensor`.
@@ -49,7 +49,7 @@
  * @param <T> data type for {@code sumValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseAdd<T extends Tensor> extends RawOp {
+public final class SparseAdd<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAdd operation.
@@ -66,15 +66,15 @@ public final class SparseAdd<T extends Tensor> extends RawOp {
    * @return a new instance of SparseAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseAdd<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape, Operand<U> thresh) {
+  public static <T extends TType, U extends TNumber> SparseAdd<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape, Operand<U> thresh) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAdd", scope.makeOpName("SparseAdd"));
-    opBuilder.addInput(aIndices.asOutput());
-    opBuilder.addInput(aValues.asOutput());
-    opBuilder.addInput(aShape.asOutput());
-    opBuilder.addInput(bIndices.asOutput());
-    opBuilder.addInput(bValues.asOutput());
-    opBuilder.addInput(bShape.asOutput());
-    opBuilder.addInput(thresh.asOutput());
+    opBuilder.addInput(aIndices.asOutput(scope));
+    opBuilder.addInput(aValues.asOutput(scope));
+    opBuilder.addInput(aShape.asOutput(scope));
+    opBuilder.addInput(bIndices.asOutput(scope));
+    opBuilder.addInput(bValues.asOutput(scope));
+    opBuilder.addInput(bShape.asOutput(scope));
+    opBuilder.addInput(thresh.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseAdd<T>(opBuilder.build());
   }
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 3e6aa064a19..f30aa37d413 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * The gradient operator for the SparseAdd op.
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code aValGrad()} output
  */
 @Operator(group = "sparse")
-public final class SparseAddGrad<T extends Tensor> extends RawOp {
+public final class SparseAddGrad<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseAddGrad operation.
@@ -54,12 +54,12 @@ public final class SparseAddGrad<T extends Tensor> extends RawOp {
    * @return a new instance of SparseAddGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseAddGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> aIndices, Operand<TInt64> bIndices, Operand<TInt64> sumIndices) {
+  public static <T extends TType> SparseAddGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> aIndices, Operand<TInt64> bIndices, Operand<TInt64> sumIndices) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseAddGrad", scope.makeOpName("SparseAddGrad"));
-    opBuilder.addInput(backpropValGrad.asOutput());
-    opBuilder.addInput(aIndices.asOutput());
-    opBuilder.addInput(bIndices.asOutput());
-    opBuilder.addInput(sumIndices.asOutput());
+    opBuilder.addInput(backpropValGrad.asOutput(scope));
+    opBuilder.addInput(aIndices.asOutput(scope));
+    opBuilder.addInput(bIndices.asOutput(scope));
+    opBuilder.addInput(sumIndices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseAddGrad<T>(opBuilder.build());
   }
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 637eef24ca2..ebb1db1a05b 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
@@ -21,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Concatenates a list of `SparseTensor` along the specified dimension.
@@ -77,7 +77,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseConcat<T extends Tensor> extends RawOp {
+public final class SparseConcat<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseConcat operation.
@@ -91,11 +91,11 @@ public final class SparseConcat<T extends Tensor> extends RawOp {
    * @return a new instance of SparseConcat
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseConcat<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<T>> values, Iterable<Operand<TInt64>> shapes, Long concatDim) {
+  public static <T extends TType> SparseConcat<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<T>> values, Iterable<Operand<TInt64>> shapes, Long concatDim) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseConcat", scope.makeOpName("SparseConcat"));
-    opBuilder.addInputList(Operands.asOutputs(indices));
-    opBuilder.addInputList(Operands.asOutputs(values));
-    opBuilder.addInputList(Operands.asOutputs(shapes));
+    opBuilder.addInputList(Operands.asOutputs(scope, indices));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
+    opBuilder.addInputList(Operands.asOutputs(scope, shapes));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("concat_dim", concatDim);
     return new SparseConcat<T>(opBuilder.build());
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 be9396e9d21..01dd68a06c1 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * A conditional accumulator for aggregating sparse gradients.
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of SparseConditionalAccumulator
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends TType> SparseConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseConditionalAccumulator", scope.makeOpName("SparseConditionalAccumulator"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -144,7 +144,7 @@ public Output<TString> handle() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return handle;
   }
   
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 dfc030fc809..0c63e102925 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
@@ -22,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Generates sparse cross from a list of sparse and dense tensors.
@@ -73,7 +73,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseCross<T extends Tensor> extends RawOp {
+public final class SparseCross<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseCross operation.
@@ -94,12 +94,12 @@ public final class SparseCross<T extends Tensor> extends RawOp {
    * @return a new instance of SparseCross
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor> SparseCross<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<?>> values, Iterable<Operand<TInt64>> shapes, Iterable<Operand<?>> denseInputs, Boolean hashedOutput, Long numBuckets, Long hashKey, DataType<T> outType, DataType<U> internalType) {
+  public static <T extends TType, U extends TType> SparseCross<T> create(Scope scope, Iterable<Operand<TInt64>> indices, Iterable<Operand<?>> values, Iterable<Operand<TInt64>> shapes, Iterable<Operand<?>> denseInputs, Boolean hashedOutput, Long numBuckets, Long hashKey, DataType<T> outType, DataType<U> internalType) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseCross", scope.makeOpName("SparseCross"));
-    opBuilder.addInputList(Operands.asOutputs(indices));
-    opBuilder.addInputList(Operands.asOutputs(values));
-    opBuilder.addInputList(Operands.asOutputs(shapes));
-    opBuilder.addInputList(Operands.asOutputs(denseInputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, indices));
+    opBuilder.addInputList(Operands.asOutputs(scope, values));
+    opBuilder.addInputList(Operands.asOutputs(scope, shapes));
+    opBuilder.addInputList(Operands.asOutputs(scope, denseInputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("hashed_output", hashedOutput);
     opBuilder.setAttr("num_buckets", numBuckets);
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 a6667f7ee45..75e033f243b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds up a SparseTensor and a dense Tensor, using these special rules:
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseAdd<T extends Tensor> extends RawOp 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.
@@ -57,12 +57,12 @@ public final class SparseDenseCwiseAdd<T extends Tensor> extends RawOp implement
    * @return a new instance of SparseDenseCwiseAdd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseDenseCwiseAdd<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
+  public static <T extends TType> SparseDenseCwiseAdd<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseDenseCwiseAdd", scope.makeOpName("SparseDenseCwiseAdd"));
-    opBuilder.addInput(spIndices.asOutput());
-    opBuilder.addInput(spValues.asOutput());
-    opBuilder.addInput(spShape.asOutput());
-    opBuilder.addInput(dense.asOutput());
+    opBuilder.addInput(spIndices.asOutput(scope));
+    opBuilder.addInput(spValues.asOutput(scope));
+    opBuilder.addInput(spShape.asOutput(scope));
+    opBuilder.addInput(dense.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseDenseCwiseAdd<T>(opBuilder.build());
   }
@@ -75,7 +75,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 07ee23bbea3..5c31f2f0f21 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Component-wise divides a SparseTensor by a dense Tensor.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseDiv<T extends Tensor> extends RawOp 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.
@@ -51,12 +51,12 @@ public final class SparseDenseCwiseDiv<T extends Tensor> extends RawOp implement
    * @return a new instance of SparseDenseCwiseDiv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseDenseCwiseDiv<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
+  public static <T extends TType> SparseDenseCwiseDiv<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseDenseCwiseDiv", scope.makeOpName("SparseDenseCwiseDiv"));
-    opBuilder.addInput(spIndices.asOutput());
-    opBuilder.addInput(spValues.asOutput());
-    opBuilder.addInput(spShape.asOutput());
-    opBuilder.addInput(dense.asOutput());
+    opBuilder.addInput(spIndices.asOutput(scope));
+    opBuilder.addInput(spValues.asOutput(scope));
+    opBuilder.addInput(spShape.asOutput(scope));
+    opBuilder.addInput(dense.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseDenseCwiseDiv<T>(opBuilder.build());
   }
@@ -69,7 +69,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 57629eb2dec..3562dbc7805 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Component-wise multiplies a SparseTensor by a dense Tensor.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseDenseCwiseMul<T extends Tensor> extends RawOp 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.
@@ -55,12 +55,12 @@ public final class SparseDenseCwiseMul<T extends Tensor> extends RawOp implement
    * @return a new instance of SparseDenseCwiseMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseDenseCwiseMul<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
+  public static <T extends TType> SparseDenseCwiseMul<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape, Operand<T> dense) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseDenseCwiseMul", scope.makeOpName("SparseDenseCwiseMul"));
-    opBuilder.addInput(spIndices.asOutput());
-    opBuilder.addInput(spValues.asOutput());
-    opBuilder.addInput(spShape.asOutput());
-    opBuilder.addInput(dense.asOutput());
+    opBuilder.addInput(spIndices.asOutput(scope));
+    opBuilder.addInput(spValues.asOutput(scope));
+    opBuilder.addInput(spShape.asOutput(scope));
+    opBuilder.addInput(dense.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseDenseCwiseMul<T>(opBuilder.build());
   }
@@ -73,7 +73,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 df6f01f7342..0a30525e1ab 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Fills empty rows in the input 2-D `SparseTensor` with a default value.
@@ -72,7 +72,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseFillEmptyRows<T extends Tensor> extends RawOp {
+public final class SparseFillEmptyRows<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseFillEmptyRows operation.
@@ -87,12 +87,12 @@ public final class SparseFillEmptyRows<T extends Tensor> extends RawOp {
    * @return a new instance of SparseFillEmptyRows
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseFillEmptyRows<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape, Operand<T> defaultValue) {
+  public static <T extends TType> SparseFillEmptyRows<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> denseShape, Operand<T> defaultValue) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseFillEmptyRows", scope.makeOpName("SparseFillEmptyRows"));
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(values.asOutput());
-    opBuilder.addInput(denseShape.asOutput());
-    opBuilder.addInput(defaultValue.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
+    opBuilder.addInput(denseShape.asOutput(scope));
+    opBuilder.addInput(defaultValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseFillEmptyRows<T>(opBuilder.build());
   }
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 5b13cc91f8b..1f7a0591a5e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * The gradient of SparseFillEmptyRows.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code dValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseFillEmptyRowsGrad<T extends Tensor> extends RawOp {
+public final class SparseFillEmptyRowsGrad<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseFillEmptyRowsGrad operation.
@@ -54,10 +54,10 @@ public final class SparseFillEmptyRowsGrad<T extends Tensor> extends RawOp {
    * @return a new instance of SparseFillEmptyRowsGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseFillEmptyRowsGrad<T> create(Scope scope, Operand<TInt64> reverseIndexMap, Operand<T> gradValues) {
+  public static <T extends TType> SparseFillEmptyRowsGrad<T> create(Scope scope, Operand<TInt64> reverseIndexMap, Operand<T> gradValues) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseFillEmptyRowsGrad", scope.makeOpName("SparseFillEmptyRowsGrad"));
-    opBuilder.addInput(reverseIndexMap.asOutput());
-    opBuilder.addInput(gradValues.asOutput());
+    opBuilder.addInput(reverseIndexMap.asOutput(scope));
+    opBuilder.addInput(gradValues.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseFillEmptyRowsGrad<T>(opBuilder.build());
   }
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 8f53c65cd61..0b41529aa81 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -101,10 +100,10 @@ private Options() {
    * @return a new instance of SparseMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseMatMul create(Scope scope, Operand<T> a, Operand<U> b, Options... options) {
+  public static <T extends TNumber, U extends TNumber> SparseMatMul create(Scope scope, Operand<T> a, Operand<U> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseMatMul", scope.makeOpName("SparseMatMul"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -160,7 +159,7 @@ public Output<TFloat32> product() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return product;
   }
   
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 8ff995ea48c..4e675a569d9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -49,7 +48,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceMax<T extends Tensor & TNumber> extends RawOp implements Operand<T> {
+public final class SparseReduceMax<T extends TNumber> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceMax}
@@ -83,12 +82,12 @@ private Options() {
    * @return a new instance of SparseReduceMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SparseReduceMax<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends TNumber> SparseReduceMax<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceMax", scope.makeOpName("SparseReduceMax"));
-    opBuilder.addInput(inputIndices.asOutput());
-    opBuilder.addInput(inputValues.asOutput());
-    opBuilder.addInput(inputShape.asOutput());
-    opBuilder.addInput(reductionAxes.asOutput());
+    opBuilder.addInput(inputIndices.asOutput(scope));
+    opBuilder.addInput(inputValues.asOutput(scope));
+    opBuilder.addInput(inputShape.asOutput(scope));
+    opBuilder.addInput(reductionAxes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -115,7 +114,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 0cb779ae607..5b5dc885a28 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -49,7 +48,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceMaxSparse<T extends Tensor & TNumber> extends RawOp {
+public final class SparseReduceMaxSparse<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceMaxSparse}
@@ -83,12 +82,12 @@ private Options() {
    * @return a new instance of SparseReduceMaxSparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SparseReduceMaxSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends TNumber> SparseReduceMaxSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceMaxSparse", scope.makeOpName("SparseReduceMaxSparse"));
-    opBuilder.addInput(inputIndices.asOutput());
-    opBuilder.addInput(inputValues.asOutput());
-    opBuilder.addInput(inputShape.asOutput());
-    opBuilder.addInput(reductionAxes.asOutput());
+    opBuilder.addInput(inputIndices.asOutput(scope));
+    opBuilder.addInput(inputValues.asOutput(scope));
+    opBuilder.addInput(inputShape.asOutput(scope));
+    opBuilder.addInput(reductionAxes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 32a0a40b660..28ec925b403 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a SparseTensor.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceSum<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseReduceSum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceSum}
@@ -82,12 +82,12 @@ private Options() {
    * @return a new instance of SparseReduceSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseReduceSum<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends TType> SparseReduceSum<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceSum", scope.makeOpName("SparseReduceSum"));
-    opBuilder.addInput(inputIndices.asOutput());
-    opBuilder.addInput(inputValues.asOutput());
-    opBuilder.addInput(inputShape.asOutput());
-    opBuilder.addInput(reductionAxes.asOutput());
+    opBuilder.addInput(inputIndices.asOutput(scope));
+    opBuilder.addInput(inputValues.asOutput(scope));
+    opBuilder.addInput(inputShape.asOutput(scope));
+    opBuilder.addInput(reductionAxes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -114,7 +114,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 23abdb81343..5b9968d832b 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the sum of elements across dimensions of a SparseTensor.
@@ -48,7 +48,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReduceSumSparse<T extends Tensor> extends RawOp {
+public final class SparseReduceSumSparse<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseReduceSumSparse}
@@ -82,12 +82,12 @@ private Options() {
    * @return a new instance of SparseReduceSumSparse
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseReduceSumSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
+  public static <T extends TType> SparseReduceSumSparse<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape, Operand<TInt32> reductionAxes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReduceSumSparse", scope.makeOpName("SparseReduceSumSparse"));
-    opBuilder.addInput(inputIndices.asOutput());
-    opBuilder.addInput(inputValues.asOutput());
-    opBuilder.addInput(inputShape.asOutput());
-    opBuilder.addInput(reductionAxes.asOutput());
+    opBuilder.addInput(inputIndices.asOutput(scope));
+    opBuilder.addInput(inputValues.asOutput(scope));
+    opBuilder.addInput(inputShape.asOutput(scope));
+    opBuilder.addInput(reductionAxes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 6199fde8aa2..d08c44c308f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Reorders a SparseTensor into the canonical, row-major ordering.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseReorder<T extends Tensor> extends RawOp {
+public final class SparseReorder<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseReorder operation.
@@ -56,11 +56,11 @@ public final class SparseReorder<T extends Tensor> extends RawOp {
    * @return a new instance of SparseReorder
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseReorder<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape) {
+  public static <T extends TType> SparseReorder<T> create(Scope scope, Operand<TInt64> inputIndices, Operand<T> inputValues, Operand<TInt64> inputShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReorder", scope.makeOpName("SparseReorder"));
-    opBuilder.addInput(inputIndices.asOutput());
-    opBuilder.addInput(inputValues.asOutput());
-    opBuilder.addInput(inputShape.asOutput());
+    opBuilder.addInput(inputIndices.asOutput(scope));
+    opBuilder.addInput(inputValues.asOutput(scope));
+    opBuilder.addInput(inputShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseReorder<T>(opBuilder.build());
   }
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 7d2799f8ffe..6b7dc8e8a84 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
@@ -62,9 +62,9 @@ public final class SparseReshape extends RawOp {
   @Endpoint(describeByClass = true)
   public static SparseReshape create(Scope scope, Operand<TInt64> inputIndices, Operand<TInt64> inputShape, Operand<TInt64> newShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseReshape", scope.makeOpName("SparseReshape"));
-    opBuilder.addInput(inputIndices.asOutput());
-    opBuilder.addInput(inputShape.asOutput());
-    opBuilder.addInput(newShape.asOutput());
+    opBuilder.addInput(inputIndices.asOutput(scope));
+    opBuilder.addInput(inputShape.asOutput(scope));
+    opBuilder.addInput(newShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseReshape(opBuilder.build());
   }
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 276076198c0..8cdeb61508f 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMean<T extends Tensor & TNumber> extends RawOp 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.
@@ -52,11 +51,11 @@ public final class SparseSegmentMean<T extends Tensor & TNumber> extends RawOp i
    * @return a new instance of SparseSegmentMean
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
+  public static <T extends TNumber, U extends TNumber> SparseSegmentMean<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentMean", scope.makeOpName("SparseSegmentMean"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentMean<T>(opBuilder.build());
   }
@@ -70,7 +69,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5abe339711b..f12deda58e8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMeanGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -51,12 +50,12 @@ public final class SparseSegmentMeanGrad<T extends Tensor & TNumber> extends Raw
    * @return a new instance of SparseSegmentMeanGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentMeanGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
+  public static <T extends TNumber, U extends TNumber> SparseSegmentMeanGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentMeanGrad", scope.makeOpName("SparseSegmentMeanGrad"));
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(outputDim0.asOutput());
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(outputDim0.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentMeanGrad<T>(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 2e32109e991..2442e767106 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -42,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentMeanWithNumSegments<T extends Tensor & TNumber> extends RawOp 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.
@@ -55,12 +54,12 @@ public final class SparseSegmentMeanWithNumSegments<T extends Tensor & TNumber>
    * @return a new instance of SparseSegmentMeanWithNumSegments
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentMeanWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentMeanWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentMeanWithNumSegments", scope.makeOpName("SparseSegmentMeanWithNumSegments"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentMeanWithNumSegments<T>(opBuilder.build());
   }
@@ -74,7 +73,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ce500c7a976..e2e2b56e4f7 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtN<T extends Tensor & TNumber> extends RawOp 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.
@@ -52,11 +51,11 @@ public final class SparseSegmentSqrtN<T extends Tensor & TNumber> extends RawOp
    * @return a new instance of SparseSegmentSqrtN
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtN<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
+  public static <T extends TNumber, U extends TNumber> SparseSegmentSqrtN<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSqrtN", scope.makeOpName("SparseSegmentSqrtN"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentSqrtN<T>(opBuilder.build());
   }
@@ -70,7 +69,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 706e8cd9d15..93b737c96a8 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -38,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtNGrad<T extends Tensor & TNumber> extends RawOp 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.
@@ -51,12 +50,12 @@ public final class SparseSegmentSqrtNGrad<T extends Tensor & TNumber> extends Ra
    * @return a new instance of SparseSegmentSqrtNGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSqrtNGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
+  public static <T extends TNumber, U extends TNumber> SparseSegmentSqrtNGrad<T> create(Scope scope, Operand<T> grad, Operand<U> indices, Operand<TInt32> segmentIds, Operand<TInt32> outputDim0) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSqrtNGrad", scope.makeOpName("SparseSegmentSqrtNGrad"));
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(outputDim0.asOutput());
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(outputDim0.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentSqrtNGrad<T>(opBuilder.build());
   }
@@ -68,7 +67,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 0d6d1081a7d..a0b30e3fca1 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -44,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSqrtNWithNumSegments<T extends Tensor & TNumber> extends RawOp 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.
@@ -57,12 +56,12 @@ public final class SparseSegmentSqrtNWithNumSegments<T extends Tensor & TNumber>
    * @return a new instance of SparseSegmentSqrtNWithNumSegments
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSqrtNWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSqrtNWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSqrtNWithNumSegments", scope.makeOpName("SparseSegmentSqrtNWithNumSegments"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentSqrtNWithNumSegments<T>(opBuilder.build());
   }
@@ -76,7 +75,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 13bcf882abe..f539b93ab86 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -65,7 +64,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSum<T extends Tensor & TNumber> extends RawOp 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.
@@ -77,11 +76,11 @@ public final class SparseSegmentSum<T extends Tensor & TNumber> extends RawOp im
    * @return a new instance of SparseSegmentSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> SparseSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
+  public static <T extends TNumber, U extends TNumber> SparseSegmentSum<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSum", scope.makeOpName("SparseSegmentSum"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentSum<T>(opBuilder.build());
   }
@@ -95,7 +94,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 598d563c82b..ac8c400fa15 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -63,7 +62,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSegmentSumWithNumSegments<T extends Tensor & TNumber> extends RawOp 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.
@@ -76,12 +75,12 @@ public final class SparseSegmentSumWithNumSegments<T extends Tensor & TNumber> e
    * @return a new instance of SparseSegmentSumWithNumSegments
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> SparseSegmentSumWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> SparseSegmentSumWithNumSegments<T> create(Scope scope, Operand<T> data, Operand<U> indices, Operand<TInt32> segmentIds, Operand<V> numSegments) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSegmentSumWithNumSegments", scope.makeOpName("SparseSegmentSumWithNumSegments"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSegmentSumWithNumSegments<T>(opBuilder.build());
   }
@@ -95,7 +94,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 bac75336e19..628371d6fea 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Slice a `SparseTensor` based on the `start` and `size`.
@@ -50,7 +50,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSlice<T extends Tensor> extends RawOp {
+public final class SparseSlice<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSlice operation.
@@ -66,13 +66,13 @@ public final class SparseSlice<T extends Tensor> extends RawOp {
    * @return a new instance of SparseSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseSlice<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Operand<TInt64> start, Operand<TInt64> size) {
+  public static <T extends TType> SparseSlice<T> create(Scope scope, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Operand<TInt64> start, Operand<TInt64> size) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSlice", scope.makeOpName("SparseSlice"));
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(values.asOutput());
-    opBuilder.addInput(shape.asOutput());
-    opBuilder.addInput(start.asOutput());
-    opBuilder.addInput(size.asOutput());
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
+    opBuilder.addInput(start.asOutput(scope));
+    opBuilder.addInput(size.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSlice<T>(opBuilder.build());
   }
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 dac276c44a3..c7454294947 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * The gradient operator for the SparseSlice op.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code valGrad()} output
  */
 @Operator(group = "sparse")
-public final class SparseSliceGrad<T extends Tensor> extends RawOp 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.
@@ -52,12 +52,12 @@ public final class SparseSliceGrad<T extends Tensor> extends RawOp implements Op
    * @return a new instance of SparseSliceGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseSliceGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> inputIndices, Operand<TInt64> inputStart, Operand<TInt64> outputIndices) {
+  public static <T extends TType> SparseSliceGrad<T> create(Scope scope, Operand<T> backpropValGrad, Operand<TInt64> inputIndices, Operand<TInt64> inputStart, Operand<TInt64> outputIndices) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSliceGrad", scope.makeOpName("SparseSliceGrad"));
-    opBuilder.addInput(backpropValGrad.asOutput());
-    opBuilder.addInput(inputIndices.asOutput());
-    opBuilder.addInput(inputStart.asOutput());
-    opBuilder.addInput(outputIndices.asOutput());
+    opBuilder.addInput(backpropValGrad.asOutput(scope));
+    opBuilder.addInput(inputIndices.asOutput(scope));
+    opBuilder.addInput(inputStart.asOutput(scope));
+    opBuilder.addInput(outputIndices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSliceGrad<T>(opBuilder.build());
   }
@@ -70,7 +70,7 @@ public Output<T> valGrad() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return valGrad;
   }
   
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 c11466395b9..6696a7dc347 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -51,7 +50,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseSoftmax<T extends Tensor & TNumber> extends RawOp 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.
@@ -64,11 +63,11 @@ public final class SparseSoftmax<T extends Tensor & TNumber> extends RawOp imple
    * @return a new instance of SparseSoftmax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SparseSoftmax<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape) {
+  public static <T extends TNumber> SparseSoftmax<T> create(Scope scope, Operand<TInt64> spIndices, Operand<T> spValues, Operand<TInt64> spShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSoftmax", scope.makeOpName("SparseSoftmax"));
-    opBuilder.addInput(spIndices.asOutput());
-    opBuilder.addInput(spValues.asOutput());
-    opBuilder.addInput(spShape.asOutput());
+    opBuilder.addInput(spIndices.asOutput(scope));
+    opBuilder.addInput(spValues.asOutput(scope));
+    opBuilder.addInput(spShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSoftmax<T>(opBuilder.build());
   }
@@ -81,7 +80,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 ce987f487fe..9def1f7db44 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -37,7 +36,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSparseMaximum<T extends Tensor & TNumber> extends RawOp {
+public final class SparseSparseMaximum<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSparseMaximum operation.
@@ -53,14 +52,14 @@ public final class SparseSparseMaximum<T extends Tensor & TNumber> extends RawOp
    * @return a new instance of SparseSparseMaximum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> SparseSparseMaximum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
+  public static <T extends TNumber> SparseSparseMaximum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSparseMaximum", scope.makeOpName("SparseSparseMaximum"));
-    opBuilder.addInput(aIndices.asOutput());
-    opBuilder.addInput(aValues.asOutput());
-    opBuilder.addInput(aShape.asOutput());
-    opBuilder.addInput(bIndices.asOutput());
-    opBuilder.addInput(bValues.asOutput());
-    opBuilder.addInput(bShape.asOutput());
+    opBuilder.addInput(aIndices.asOutput(scope));
+    opBuilder.addInput(aValues.asOutput(scope));
+    opBuilder.addInput(aShape.asOutput(scope));
+    opBuilder.addInput(bIndices.asOutput(scope));
+    opBuilder.addInput(bValues.asOutput(scope));
+    opBuilder.addInput(bShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSparseMaximum<T>(opBuilder.build());
   }
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 2d376f040b7..277c219357b 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the element-wise min of two SparseTensors.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSparseMinimum<T extends Tensor> extends RawOp {
+public final class SparseSparseMinimum<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSparseMinimum operation.
@@ -52,14 +52,14 @@ public final class SparseSparseMinimum<T extends Tensor> extends RawOp {
    * @return a new instance of SparseSparseMinimum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseSparseMinimum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
+  public static <T extends TType> SparseSparseMinimum<T> create(Scope scope, Operand<TInt64> aIndices, Operand<T> aValues, Operand<TInt64> aShape, Operand<TInt64> bIndices, Operand<T> bValues, Operand<TInt64> bShape) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSparseMinimum", scope.makeOpName("SparseSparseMinimum"));
-    opBuilder.addInput(aIndices.asOutput());
-    opBuilder.addInput(aValues.asOutput());
-    opBuilder.addInput(aShape.asOutput());
-    opBuilder.addInput(bIndices.asOutput());
-    opBuilder.addInput(bValues.asOutput());
-    opBuilder.addInput(bShape.asOutput());
+    opBuilder.addInput(aIndices.asOutput(scope));
+    opBuilder.addInput(aValues.asOutput(scope));
+    opBuilder.addInput(aShape.asOutput(scope));
+    opBuilder.addInput(bIndices.asOutput(scope));
+    opBuilder.addInput(bValues.asOutput(scope));
+    opBuilder.addInput(bShape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseSparseMinimum<T>(opBuilder.build());
   }
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 3e64b620a18..b3862924f36 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,12 +23,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Split a `SparseTensor` into `num_split` tensors along one dimension.
@@ -54,7 +54,7 @@
  * @param <T> data type for {@code outputValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseSplit<T extends Tensor> extends RawOp {
+public final class SparseSplit<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SparseSplit operation.
@@ -71,12 +71,12 @@ public final class SparseSplit<T extends Tensor> extends RawOp {
    * @return a new instance of SparseSplit
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseSplit<T> create(Scope scope, Operand<TInt64> splitDim, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Long numSplit) {
+  public static <T extends TType> SparseSplit<T> create(Scope scope, Operand<TInt64> splitDim, Operand<TInt64> indices, Operand<T> values, Operand<TInt64> shape, Long numSplit) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseSplit", scope.makeOpName("SparseSplit"));
-    opBuilder.addInput(splitDim.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(values.asOutput());
-    opBuilder.addInput(shape.asOutput());
+    opBuilder.addInput(splitDim.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
+    opBuilder.addInput(shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_split", numSplit);
     return new SparseSplit<T>(opBuilder.build());
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 c3b94de3eb5..7f89777126a 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`.
@@ -36,7 +36,7 @@
  * @param <U> data type for {@code output()} output
  */
 @Operator(group = "sparse")
-public final class SparseTensorDenseAdd<U extends Tensor> extends RawOp 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.
@@ -49,12 +49,12 @@ public final class SparseTensorDenseAdd<U extends Tensor> extends RawOp implemen
    * @return a new instance of SparseTensorDenseAdd
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseAdd<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<T> aShape, Operand<U> b) {
+  public static <U extends TType, T extends TNumber> SparseTensorDenseAdd<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<T> aShape, Operand<U> b) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorDenseAdd", scope.makeOpName("SparseTensorDenseAdd"));
-    opBuilder.addInput(aIndices.asOutput());
-    opBuilder.addInput(aValues.asOutput());
-    opBuilder.addInput(aShape.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(aIndices.asOutput(scope));
+    opBuilder.addInput(aValues.asOutput(scope));
+    opBuilder.addInput(aShape.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SparseTensorDenseAdd<U>(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<U> output() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return output;
   }
   
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 142d6689591..56fe3f8c031 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Multiply SparseTensor (of rank 2) "A" by dense matrix "B".
@@ -45,7 +45,7 @@
  * @param <U> data type for {@code product()} output
  */
 @Operator(group = "sparse")
-public final class SparseTensorDenseMatMul<U extends Tensor> extends RawOp implements Operand<U> {
+public final class SparseTensorDenseMatMul<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseTensorDenseMatMul}
@@ -89,12 +89,12 @@ private Options() {
    * @return a new instance of SparseTensorDenseMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> SparseTensorDenseMatMul<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<TInt64> aShape, Operand<U> b, Options... options) {
+  public static <U extends TType, T extends TNumber> SparseTensorDenseMatMul<U> create(Scope scope, Operand<T> aIndices, Operand<U> aValues, Operand<TInt64> aShape, Operand<U> b, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseTensorDenseMatMul", scope.makeOpName("SparseTensorDenseMatMul"));
-    opBuilder.addInput(aIndices.asOutput());
-    opBuilder.addInput(aValues.asOutput());
-    opBuilder.addInput(aShape.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(aIndices.asOutput(scope));
+    opBuilder.addInput(aValues.asOutput(scope));
+    opBuilder.addInput(aShape.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -132,7 +132,7 @@ public Output<U> product() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return product;
   }
   
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 5e238fd902e..217940a30ef 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Converts a sparse representation into a dense tensor.
@@ -52,7 +52,7 @@
  * @param <U> data type for {@code dense()} output
  */
 @Operator(group = "sparse")
-public final class SparseToDense<U extends Tensor> extends RawOp implements Operand<U> {
+public final class SparseToDense<U extends TType> extends RawOp implements Operand<U> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseToDense}
@@ -89,12 +89,12 @@ private Options() {
    * @return a new instance of SparseToDense
    */
   @Endpoint(describeByClass = true)
-  public static <U extends Tensor, T extends Tensor & TNumber> SparseToDense<U> create(Scope scope, Operand<T> sparseIndices, Operand<T> outputShape, Operand<U> sparseValues, Operand<U> defaultValue, Options... options) {
+  public static <U extends TType, T extends TNumber> SparseToDense<U> create(Scope scope, Operand<T> sparseIndices, Operand<T> outputShape, Operand<U> sparseValues, Operand<U> defaultValue, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseToDense", scope.makeOpName("SparseToDense"));
-    opBuilder.addInput(sparseIndices.asOutput());
-    opBuilder.addInput(outputShape.asOutput());
-    opBuilder.addInput(sparseValues.asOutput());
-    opBuilder.addInput(defaultValue.asOutput());
+    opBuilder.addInput(sparseIndices.asOutput(scope));
+    opBuilder.addInput(outputShape.asOutput(scope));
+    opBuilder.addInput(sparseValues.asOutput(scope));
+    opBuilder.addInput(defaultValue.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -122,7 +122,7 @@ public Output<U> dense() {
   }
   
   @Override
-  public Output<U> asOutput() {
+  public Output<U> asOutput(Scope scope) {
     return dense;
   }
   
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 2120f7c38df..51ab94d10bd 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies set operation along last dimension of 2 `SparseTensor` inputs.
@@ -58,7 +58,7 @@
  * @param <T> data type for {@code resultValues()} output
  */
 @Operator(group = "sparse")
-public final class SparseToSparseSetOperation<T extends Tensor> extends RawOp {
+public final class SparseToSparseSetOperation<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.SparseToSparseSetOperation}
@@ -102,14 +102,14 @@ private Options() {
    * @return a new instance of SparseToSparseSetOperation
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SparseToSparseSetOperation<T> create(Scope scope, Operand<TInt64> set1Indices, Operand<T> set1Values, Operand<TInt64> set1Shape, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
+  public static <T extends TType> SparseToSparseSetOperation<T> create(Scope scope, Operand<TInt64> set1Indices, Operand<T> set1Values, Operand<TInt64> set1Shape, Operand<TInt64> set2Indices, Operand<T> set2Values, Operand<TInt64> set2Shape, String setOperation, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseToSparseSetOperation", scope.makeOpName("SparseToSparseSetOperation"));
-    opBuilder.addInput(set1Indices.asOutput());
-    opBuilder.addInput(set1Values.asOutput());
-    opBuilder.addInput(set1Shape.asOutput());
-    opBuilder.addInput(set2Indices.asOutput());
-    opBuilder.addInput(set2Values.asOutput());
-    opBuilder.addInput(set2Shape.asOutput());
+    opBuilder.addInput(set1Indices.asOutput(scope));
+    opBuilder.addInput(set1Values.asOutput(scope));
+    opBuilder.addInput(set1Shape.asOutput(scope));
+    opBuilder.addInput(set2Indices.asOutput(scope));
+    opBuilder.addInput(set2Values.asOutput(scope));
+    opBuilder.addInput(set2Shape.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("set_operation", setOperation);
     if (options != null) {
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 3a410449626..f659bbbaf58 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Read `SparseTensors` from a `SparseTensorsMap` and concatenate them.
@@ -80,7 +80,7 @@
  * @param <T> data type for {@code sparseValues()} output
  */
 @Operator(group = "sparse")
-public final class TakeManySparseFromTensorsMap<T extends Tensor> extends RawOp {
+public final class TakeManySparseFromTensorsMap<T extends TType> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.sparse.TakeManySparseFromTensorsMap}
@@ -124,9 +124,9 @@ private Options() {
    * @return a new instance of TakeManySparseFromTensorsMap
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TakeManySparseFromTensorsMap<T> create(Scope scope, Operand<TInt64> sparseHandles, DataType<T> dtype, Options... options) {
+  public static <T extends TType> TakeManySparseFromTensorsMap<T> create(Scope scope, Operand<TInt64> sparseHandles, DataType<T> dtype, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TakeManySparseFromTensorsMap", scope.makeOpName("TakeManySparseFromTensorsMap"));
-    opBuilder.addInput(sparseHandles.asOutput());
+    opBuilder.addInput(sparseHandles.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     if (options != null) {
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 448a161166b..336e06f03d3 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
@@ -74,7 +74,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Join create(Scope scope, Iterable<Operand<TString>> inputs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringJoin", scope.makeOpName("Join"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -100,7 +100,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 14ac2b2a660..921aaf348d3 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
@@ -69,7 +69,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Lower create(Scope scope, Operand<TString> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringLower", scope.makeOpName("Lower"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -95,7 +95,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 615262737c6..883b36d951f 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
@@ -100,8 +100,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static ReduceJoin create(Scope scope, Operand<TString> inputs, Operand<TInt32> reductionIndices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ReduceJoin", scope.makeOpName("ReduceJoin"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(reductionIndices.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(reductionIndices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -139,7 +139,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 62923005059..3d8d55136ef 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
@@ -59,8 +59,8 @@ public final class RegexFullMatch extends RawOp implements Operand<TBool> {
   @Endpoint(describeByClass = true)
   public static RegexFullMatch create(Scope scope, Operand<TString> input, Operand<TString> pattern) {
     OperationBuilder opBuilder = scope.env().opBuilder("RegexFullMatch", scope.makeOpName("RegexFullMatch"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(pattern.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(pattern.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new RegexFullMatch(opBuilder.build());
   }
@@ -73,7 +73,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 39d76d9115b..12a2c4dfd11 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
@@ -71,9 +71,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static RegexReplace create(Scope scope, Operand<TString> input, Operand<TString> pattern, Operand<TString> rewrite, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RegexReplace", scope.makeOpName("RegexReplace"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(pattern.asOutput());
-    opBuilder.addInput(rewrite.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(pattern.asOutput(scope));
+    opBuilder.addInput(rewrite.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -102,7 +102,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 fe6714ca733..5b903757282 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
@@ -51,7 +51,7 @@ public final class StaticRegexFullMatch extends RawOp implements Operand<TBool>
   @Endpoint(describeByClass = true)
   public static StaticRegexFullMatch create(Scope scope, Operand<TString> input, String pattern) {
     OperationBuilder opBuilder = scope.env().opBuilder("StaticRegexFullMatch", scope.makeOpName("StaticRegexFullMatch"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("pattern", pattern);
     return new StaticRegexFullMatch(opBuilder.build());
@@ -65,7 +65,7 @@ public Output<TBool> output() {
   }
   
   @Override
-  public Output<TBool> asOutput() {
+  public Output<TBool> asOutput(Scope scope) {
     return output;
   }
   
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 e09c93144d4..2f66ea0c0f5 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
@@ -67,7 +67,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static StaticRegexReplace create(Scope scope, Operand<TString> input, String pattern, String rewrite, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StaticRegexReplace", scope.makeOpName("StaticRegexReplace"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("pattern", pattern);
     opBuilder.setAttr("rewrite", rewrite);
@@ -97,7 +97,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 0e6798c4bf4..d7aff7a48f5 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
@@ -84,7 +84,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static StringFormat create(Scope scope, Iterable<Operand<?>> inputs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringFormat", scope.makeOpName("StringFormat"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -131,7 +131,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 ff820abbea3..4700ba2caa6 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
@@ -77,7 +77,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static StringLength create(Scope scope, Operand<TString> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringLength", scope.makeOpName("StringLength"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -109,7 +109,7 @@ public Output<TInt32> output() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return output;
   }
   
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 ea84605c368..421155ab9f7 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -40,7 +39,7 @@
  * @param <T> data type for {@code ngramsSplits()} output
  */
 @Operator(group = "strings")
-public final class StringNGrams<T extends Tensor & TNumber> extends RawOp {
+public final class StringNGrams<T extends TNumber> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new StringNGrams operation.
@@ -63,10 +62,10 @@ public final class StringNGrams<T extends Tensor & TNumber> extends RawOp {
    * @return a new instance of StringNGrams
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> StringNGrams<T> create(Scope scope, Operand<TString> data, Operand<T> dataSplits, String separator, List<Long> ngramWidths, String leftPad, String rightPad, Long padWidth, Boolean preserveShortSequences) {
+  public static <T extends TNumber> StringNGrams<T> create(Scope scope, Operand<TString> data, Operand<T> dataSplits, String separator, List<Long> ngramWidths, String leftPad, String rightPad, Long padWidth, Boolean preserveShortSequences) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringNGrams", scope.makeOpName("StringNGrams"));
-    opBuilder.addInput(data.asOutput());
-    opBuilder.addInput(dataSplits.asOutput());
+    opBuilder.addInput(data.asOutput(scope));
+    opBuilder.addInput(dataSplits.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("separator", separator);
     long[] ngramWidthsArray = new long[ngramWidths.size()];
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 d1e4b45d745..3f380cb8d08 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
@@ -89,8 +89,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static StringSplit create(Scope scope, Operand<TString> input, Operand<TString> sep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringSplitV2", scope.makeOpName("StringSplit"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(sep.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(sep.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 eb8f1a23a4a..15e6b7ef2e9 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
@@ -43,7 +43,7 @@ public final class Strip extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static Strip create(Scope scope, Operand<TString> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringStrip", scope.makeOpName("Strip"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Strip(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 520a5c9542e..7a8029e51ae 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -145,11 +144,11 @@ private Options() {
    * @return a new instance of Substr
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> Substr create(Scope scope, Operand<TString> input, Operand<T> pos, Operand<T> len, Options... options) {
+  public static <T extends TNumber> Substr create(Scope scope, Operand<TString> input, Operand<T> pos, Operand<T> len, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Substr", scope.makeOpName("Substr"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(pos.asOutput());
-    opBuilder.addInput(len.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(pos.asOutput(scope));
+    opBuilder.addInput(len.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -180,7 +179,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 82d26aebe40..f84a249d36f 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
@@ -52,7 +52,7 @@ public final class ToHashBucket extends RawOp implements Operand<TInt64> {
   @Endpoint(describeByClass = true)
   public static ToHashBucket create(Scope scope, Operand<TString> stringTensor, Long numBuckets) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringToHashBucket", scope.makeOpName("ToHashBucket"));
-    opBuilder.addInput(stringTensor.asOutput());
+    opBuilder.addInput(stringTensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_buckets", numBuckets);
     return new ToHashBucket(opBuilder.build());
@@ -66,7 +66,7 @@ public Output<TInt64> output() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return output;
   }
   
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 62737da0d0d..5a343175a3e 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
@@ -57,7 +57,7 @@ public final class ToHashBucketFast extends RawOp implements Operand<TInt64> {
   @Endpoint(describeByClass = true)
   public static ToHashBucketFast create(Scope scope, Operand<TString> input, Long numBuckets) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringToHashBucketFast", scope.makeOpName("ToHashBucketFast"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_buckets", numBuckets);
     return new ToHashBucketFast(opBuilder.build());
@@ -71,7 +71,7 @@ public Output<TInt64> output() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return output;
   }
   
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 c27d7053165..0c6d66ddaa4 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
@@ -67,7 +67,7 @@ public final class ToHashBucketStrong extends RawOp implements Operand<TInt64> {
   @Endpoint(describeByClass = true)
   public static ToHashBucketStrong create(Scope scope, Operand<TString> input, Long numBuckets, List<Long> key) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringToHashBucketStrong", scope.makeOpName("ToHashBucketStrong"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_buckets", numBuckets);
     long[] keyArray = new long[key.size()];
@@ -86,7 +86,7 @@ public Output<TInt64> output() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return output;
   }
   
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 bf77911551a..1623cdc54cd 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -47,7 +46,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "strings")
-public final class ToNumber<T extends Tensor & TNumber> extends RawOp 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.
@@ -58,9 +57,9 @@ public final class ToNumber<T extends Tensor & TNumber> extends RawOp implements
    * @return a new instance of ToNumber
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ToNumber<T> create(Scope scope, Operand<TString> stringTensor, DataType<T> outType) {
+  public static <T extends TNumber> ToNumber<T> create(Scope scope, Operand<TString> stringTensor, DataType<T> outType) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringToNumber", scope.makeOpName("ToNumber"));
-    opBuilder.addInput(stringTensor.asOutput());
+    opBuilder.addInput(stringTensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("out_type", outType);
     return new ToNumber<T>(opBuilder.build());
@@ -86,7 +85,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 a4201a1be21..ae8c060fcca 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -54,7 +53,7 @@
  * 
  * @param <T> data type for {@code rowSplits()} output
  */
-public final class UnicodeDecode<T extends Tensor & TNumber> extends RawOp {
+public final class UnicodeDecode<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeDecode}
@@ -116,9 +115,9 @@ private Options() {
    * @return a new instance of UnicodeDecode
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> UnicodeDecode<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
+  public static <T extends TNumber> UnicodeDecode<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeDecode", scope.makeOpName("UnicodeDecode"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("input_encoding", inputEncoding);
     opBuilder.setAttr("Tsplits", Tsplits);
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 a1feac2fd3c..7a11b3e06ea 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -60,7 +59,7 @@
  * 
  * @param <T> data type for {@code rowSplits()} output
  */
-public final class UnicodeDecodeWithOffsets<T extends Tensor & TNumber> extends RawOp {
+public final class UnicodeDecodeWithOffsets<T extends TNumber> extends RawOp {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.strings.UnicodeDecodeWithOffsets}
@@ -122,9 +121,9 @@ private Options() {
    * @return a new instance of UnicodeDecodeWithOffsets
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> UnicodeDecodeWithOffsets<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
+  public static <T extends TNumber> UnicodeDecodeWithOffsets<T> create(Scope scope, Operand<TString> input, String inputEncoding, DataType<T> Tsplits, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeDecodeWithOffsets", scope.makeOpName("UnicodeDecodeWithOffsets"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("input_encoding", inputEncoding);
     opBuilder.setAttr("Tsplits", Tsplits);
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 b7fb132260f..c4dc360bd8a 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -102,10 +101,10 @@ private Options() {
    * @return a new instance of UnicodeEncode
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> UnicodeEncode create(Scope scope, Operand<TInt32> inputValues, Operand<T> inputSplits, String outputEncoding, Options... options) {
+  public static <T extends TNumber> UnicodeEncode create(Scope scope, Operand<TInt32> inputValues, Operand<T> inputSplits, String outputEncoding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeEncode", scope.makeOpName("UnicodeEncode"));
-    opBuilder.addInput(inputValues.asOutput());
-    opBuilder.addInput(inputSplits.asOutput());
+    opBuilder.addInput(inputValues.asOutput(scope));
+    opBuilder.addInput(inputSplits.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("output_encoding", outputEncoding);
     if (options != null) {
@@ -152,7 +151,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 3da3bac675c..b5c5eaeaa33 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
@@ -54,7 +54,7 @@ public final class UnicodeScript extends RawOp implements Operand<TInt32> {
   @Endpoint(describeByClass = true)
   public static UnicodeScript create(Scope scope, Operand<TInt32> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeScript", scope.makeOpName("UnicodeScript"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new UnicodeScript(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<TInt32> output() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return output;
   }
   
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 4b4e03fda8d..b7366bc621a 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
@@ -135,7 +135,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static UnicodeTranscode create(Scope scope, Operand<TString> input, String inputEncoding, String outputEncoding, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnicodeTranscode", scope.makeOpName("UnicodeTranscode"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("input_encoding", inputEncoding);
     opBuilder.setAttr("output_encoding", outputEncoding);
@@ -199,7 +199,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 a6cffe58bcc..4ad758f70ea 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -93,11 +92,11 @@ private Options() {
    * @return a new instance of UnsortedSegmentJoin
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber> UnsortedSegmentJoin create(Scope scope, Operand<TString> inputs, Operand<T> segmentIds, Operand<U> numSegments, Options... options) {
+  public static <T extends TNumber, U extends TNumber> UnsortedSegmentJoin create(Scope scope, Operand<TString> inputs, Operand<T> segmentIds, Operand<U> numSegments, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("UnsortedSegmentJoin", scope.makeOpName("UnsortedSegmentJoin"));
-    opBuilder.addInput(inputs.asOutput());
-    opBuilder.addInput(segmentIds.asOutput());
-    opBuilder.addInput(numSegments.asOutput());
+    opBuilder.addInput(inputs.asOutput(scope));
+    opBuilder.addInput(segmentIds.asOutput(scope));
+    opBuilder.addInput(numSegments.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -123,7 +122,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 343e4c58d5d..eb21b354bcc 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
@@ -69,7 +69,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static Upper create(Scope scope, Operand<TString> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("StringUpper", scope.makeOpName("Upper"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -95,7 +95,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 f8382c2cede..203e4162aaa 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
@@ -81,9 +81,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static AudioSummary create(Scope scope, Operand<TString> tag, Operand<TFloat32> tensor, Operand<TFloat32> sampleRate, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("AudioSummaryV2", scope.makeOpName("AudioSummary"));
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(sampleRate.asOutput());
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(sampleRate.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -110,7 +110,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 c056b2f4f35..c54ccadbb1e 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
@@ -39,7 +39,7 @@ public final class CloseSummaryWriter extends RawOp {
   @Endpoint(describeByClass = true)
   public static CloseSummaryWriter create(Scope scope, Operand<?> writer) {
     OperationBuilder opBuilder = scope.env().opBuilder("CloseSummaryWriter", scope.makeOpName("CloseSummaryWriter"));
-    opBuilder.addInput(writer.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new CloseSummaryWriter(opBuilder.build());
   }
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 50cfefb2e9f..f7b510ffd7e 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
@@ -44,11 +44,11 @@ public final class CreateSummaryDbWriter extends RawOp {
   @Endpoint(describeByClass = true)
   public static CreateSummaryDbWriter create(Scope scope, Operand<?> writer, Operand<TString> dbUri, Operand<TString> experimentName, Operand<TString> runName, Operand<TString> userName) {
     OperationBuilder opBuilder = scope.env().opBuilder("CreateSummaryDbWriter", scope.makeOpName("CreateSummaryDbWriter"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(dbUri.asOutput());
-    opBuilder.addInput(experimentName.asOutput());
-    opBuilder.addInput(runName.asOutput());
-    opBuilder.addInput(userName.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(dbUri.asOutput(scope));
+    opBuilder.addInput(experimentName.asOutput(scope));
+    opBuilder.addInput(runName.asOutput(scope));
+    opBuilder.addInput(userName.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new CreateSummaryDbWriter(opBuilder.build());
   }
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 13130955bca..df17adbe3c7 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
@@ -45,11 +45,11 @@ public final class CreateSummaryFileWriter extends RawOp {
   @Endpoint(describeByClass = true)
   public static CreateSummaryFileWriter create(Scope scope, Operand<?> writer, Operand<TString> logdir, Operand<TInt32> maxQueue, Operand<TInt32> flushMillis, Operand<TString> filenameSuffix) {
     OperationBuilder opBuilder = scope.env().opBuilder("CreateSummaryFileWriter", scope.makeOpName("CreateSummaryFileWriter"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(logdir.asOutput());
-    opBuilder.addInput(maxQueue.asOutput());
-    opBuilder.addInput(flushMillis.asOutput());
-    opBuilder.addInput(filenameSuffix.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(logdir.asOutput(scope));
+    opBuilder.addInput(maxQueue.asOutput(scope));
+    opBuilder.addInput(flushMillis.asOutput(scope));
+    opBuilder.addInput(filenameSuffix.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new CreateSummaryFileWriter(opBuilder.build());
   }
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 16babb3df73..9cc8ce8a247 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
@@ -39,7 +39,7 @@ public final class FlushSummaryWriter extends RawOp {
   @Endpoint(describeByClass = true)
   public static FlushSummaryWriter create(Scope scope, Operand<?> writer) {
     OperationBuilder opBuilder = scope.env().opBuilder("FlushSummaryWriter", scope.makeOpName("FlushSummaryWriter"));
-    opBuilder.addInput(writer.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new FlushSummaryWriter(opBuilder.build());
   }
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 9a4b70596a2..57333d069d9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -50,10 +49,10 @@ public final class HistogramSummary extends RawOp implements Operand<TString> {
    * @return a new instance of HistogramSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> HistogramSummary create(Scope scope, Operand<TString> tag, Operand<T> values) {
+  public static <T extends TNumber> HistogramSummary create(Scope scope, Operand<TString> tag, Operand<T> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("HistogramSummary", scope.makeOpName("HistogramSummary"));
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new HistogramSummary(opBuilder.build());
   }
@@ -66,7 +65,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 4f0adcdf4b0..925b5d58d76 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
@@ -121,10 +121,10 @@ private Options() {
    * @return a new instance of ImageSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ImageSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Options... options) {
+  public static <T extends TNumber> ImageSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ImageSummary", scope.makeOpName("ImageSummary"));
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -161,7 +161,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 736aa827d82..81e70e1d26a 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
@@ -41,8 +41,8 @@ public final class ImportEvent extends RawOp {
   @Endpoint(describeByClass = true)
   public static ImportEvent create(Scope scope, Operand<?> writer, Operand<TString> event) {
     OperationBuilder opBuilder = scope.env().opBuilder("ImportEvent", scope.makeOpName("ImportEvent"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(event.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(event.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ImportEvent(opBuilder.build());
   }
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 32ec38a516a..69f4ec11552 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
@@ -53,7 +53,7 @@ public final class MergeSummary extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static MergeSummary create(Scope scope, Iterable<Operand<TString>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("MergeSummary", scope.makeOpName("MergeSummary"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new MergeSummary(opBuilder.build());
   }
@@ -66,7 +66,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 20fed2d4d5c..b3633ef3a6b 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -47,10 +46,10 @@ public final class ScalarSummary extends RawOp implements Operand<TString> {
    * @return a new instance of ScalarSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> ScalarSummary create(Scope scope, Operand<TString> tags, Operand<T> values) {
+  public static <T extends TNumber> ScalarSummary create(Scope scope, Operand<TString> tags, Operand<T> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("ScalarSummary", scope.makeOpName("ScalarSummary"));
-    opBuilder.addInput(tags.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(tags.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ScalarSummary(opBuilder.build());
   }
@@ -63,7 +62,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 525db2a64e8..143ff29c6a3 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
@@ -42,7 +42,7 @@ public final class StatsAggregatorSummary extends RawOp implements Operand<TStri
   @Endpoint(describeByClass = true)
   public static StatsAggregatorSummary create(Scope scope, Operand<?> iterator) {
     OperationBuilder opBuilder = scope.env().opBuilder("StatsAggregatorSummary", scope.makeOpName("StatsAggregatorSummary"));
-    opBuilder.addInput(iterator.asOutput());
+    opBuilder.addInput(iterator.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new StatsAggregatorSummary(opBuilder.build());
   }
@@ -54,7 +54,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 3a1e03afea5..2fef41fed6b 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,15 +21,15 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  */
-public final class SummaryWriter extends RawOp implements Operand<Tensor> {
+public final class SummaryWriter extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.summary.SummaryWriter}
@@ -105,8 +105,8 @@ public Output<?> writer() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) writer;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) writer;
   }
   
   private Output<?> writer;
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 ed7ac378d5c..383ae5dc3c8 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Outputs a `Summary` protocol buffer with a tensor and per-plugin data.
@@ -45,11 +45,11 @@ public final class TensorSummary extends RawOp implements Operand<TString> {
    * @return a new instance of TensorSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TensorSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Operand<TString> serializedSummaryMetadata) {
+  public static <T extends TType> TensorSummary create(Scope scope, Operand<TString> tag, Operand<T> tensor, Operand<TString> serializedSummaryMetadata) {
     OperationBuilder opBuilder = scope.env().opBuilder("TensorSummaryV2", scope.makeOpName("TensorSummary"));
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(serializedSummaryMetadata.asOutput());
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(serializedSummaryMetadata.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TensorSummary(opBuilder.build());
   }
@@ -61,7 +61,7 @@ public Output<TString> summary() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return summary;
   }
   
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 69e42753c7c..457a3e37037 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
@@ -66,11 +66,11 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static WriteAudioSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<TFloat32> tensor, Operand<TFloat32> sampleRate, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteAudioSummary", scope.makeOpName("WriteAudioSummary"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(step.asOutput());
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(sampleRate.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(sampleRate.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 0d6b11f1f6d..1560b6bdc22 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
@@ -43,9 +43,9 @@ public final class WriteGraphSummary extends RawOp {
   @Endpoint(describeByClass = true)
   public static WriteGraphSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteGraphSummary", scope.makeOpName("WriteGraphSummary"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(step.asOutput());
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WriteGraphSummary(opBuilder.build());
   }
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 a5d7fe41127..acf6b8672ca 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,6 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -44,12 +43,12 @@ public final class WriteHistogramSummary extends RawOp {
    * @return a new instance of WriteHistogramSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> WriteHistogramSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> values) {
+  public static <T extends TNumber> WriteHistogramSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteHistogramSummary", scope.makeOpName("WriteHistogramSummary"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(step.asOutput());
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WriteHistogramSummary(opBuilder.build());
   }
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 18dac4290f3..5ceb337bf73 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,6 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -66,13 +65,13 @@ private Options() {
    * @return a new instance of WriteImageSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> WriteImageSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> tensor, Operand<TUint8> badColor, Options... options) {
+  public static <T extends TNumber> WriteImageSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> tensor, Operand<TUint8> badColor, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteImageSummary", scope.makeOpName("WriteImageSummary"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(step.asOutput());
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(badColor.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(badColor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 e781534b31b..2dd03780cdc 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
@@ -43,9 +43,9 @@ public final class WriteRawProtoSummary extends RawOp {
   @Endpoint(describeByClass = true)
   public static WriteRawProtoSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tensor) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteRawProtoSummary", scope.makeOpName("WriteRawProtoSummary"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(step.asOutput());
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WriteRawProtoSummary(opBuilder.build());
   }
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 1eed2c27f17..7a9d0b73290 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,6 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -44,12 +43,12 @@ public final class WriteScalarSummary extends RawOp {
    * @return a new instance of WriteScalarSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> WriteScalarSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> value) {
+  public static <T extends TNumber> WriteScalarSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<TString> tag, Operand<T> value) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteScalarSummary", scope.makeOpName("WriteScalarSummary"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(step.asOutput());
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(value.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(value.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WriteScalarSummary(opBuilder.build());
   }
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 93c83d7cf6f..d3c53242980 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  */
@@ -44,13 +44,13 @@ public final class WriteSummary extends RawOp {
    * @return a new instance of WriteSummary
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> WriteSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<T> tensor, Operand<TString> tag, Operand<TString> summaryMetadata) {
+  public static <T extends TType> WriteSummary create(Scope scope, Operand<?> writer, Operand<TInt64> step, Operand<T> tensor, Operand<TString> tag, Operand<TString> summaryMetadata) {
     OperationBuilder opBuilder = scope.env().opBuilder("WriteSummary", scope.makeOpName("WriteSummary"));
-    opBuilder.addInput(writer.asOutput());
-    opBuilder.addInput(step.asOutput());
-    opBuilder.addInput(tensor.asOutput());
-    opBuilder.addInput(tag.asOutput());
-    opBuilder.addInput(summaryMetadata.asOutput());
+    opBuilder.addInput(writer.asOutput(scope));
+    opBuilder.addInput(step.asOutput(scope));
+    opBuilder.addInput(tensor.asOutput(scope));
+    opBuilder.addInput(tag.asOutput(scope));
+    opBuilder.addInput(summaryMetadata.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WriteSummary(opBuilder.build());
   }
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 2ab39e2c393..d2e1cd22c54 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * An Op to exchange data across TPU replicas.
@@ -50,7 +50,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class AllToAll<T extends Tensor> extends RawOp 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.
@@ -67,10 +67,10 @@ public final class AllToAll<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of AllToAll
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AllToAll<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment, Long concatDimension, Long splitDimension, Long splitCount) {
+  public static <T extends TType> AllToAll<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment, Long concatDimension, Long splitDimension, Long splitCount) {
     OperationBuilder opBuilder = scope.env().opBuilder("AllToAll", scope.makeOpName("AllToAll"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(groupAssignment.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(groupAssignment.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("concat_dimension", concatDimension);
     opBuilder.setAttr("split_dimension", splitDimension);
@@ -86,7 +86,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 d12c4a0d167..ef1ff020af3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * An Op to permute tensors across replicated TPU instances.
@@ -39,7 +39,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CollectivePermute<T extends Tensor> extends RawOp 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.
@@ -51,10 +51,10 @@ public final class CollectivePermute<T extends Tensor> extends RawOp implements
    * @return a new instance of CollectivePermute
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> CollectivePermute<T> create(Scope scope, Operand<T> input, Operand<TInt32> sourceTargetPairs) {
+  public static <T extends TType> CollectivePermute<T> create(Scope scope, Operand<T> input, Operand<TInt32> sourceTargetPairs) {
     OperationBuilder opBuilder = scope.env().opBuilder("CollectivePermute", scope.makeOpName("CollectivePermute"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(sourceTargetPairs.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(sourceTargetPairs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new CollectivePermute<T>(opBuilder.build());
   }
@@ -67,7 +67,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 73f1bfceb3e..7042095ba34 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
@@ -166,7 +166,7 @@ public Output<TString> topology() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return topology;
   }
   
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 2e5c63f42fa..8cdad9500e9 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,6 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -41,7 +40,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class CrossReplicaSum<T extends Tensor & TNumber> extends RawOp 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.
@@ -54,10 +53,10 @@ public final class CrossReplicaSum<T extends Tensor & TNumber> extends RawOp imp
    * @return a new instance of CrossReplicaSum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber> CrossReplicaSum<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment) {
+  public static <T extends TNumber> CrossReplicaSum<T> create(Scope scope, Operand<T> input, Operand<TInt32> groupAssignment) {
     OperationBuilder opBuilder = scope.env().opBuilder("CrossReplicaSum", scope.makeOpName("CrossReplicaSum"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(groupAssignment.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(groupAssignment.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new CrossReplicaSum<T>(opBuilder.build());
   }
@@ -70,7 +69,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 7b499d87664..8ee1d6dd670 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
@@ -69,8 +69,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static EnqueueTPUEmbeddingIntegerBatch create(Scope scope, Iterable<Operand<TInt32>> batch, Operand<TString> modeOverride, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EnqueueTPUEmbeddingIntegerBatch", scope.makeOpName("EnqueueTPUEmbeddingIntegerBatch"));
-    opBuilder.addInputList(Operands.asOutputs(batch));
-    opBuilder.addInput(modeOverride.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, batch));
+    opBuilder.addInput(modeOverride.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 f5078ce2b82..1553e506c06 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
@@ -21,7 +21,6 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -99,12 +98,12 @@ private Options() {
    * @return a new instance of EnqueueTPUEmbeddingSparseBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> EnqueueTPUEmbeddingSparseBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, Options... options) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> EnqueueTPUEmbeddingSparseBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EnqueueTPUEmbeddingSparseBatch", scope.makeOpName("EnqueueTPUEmbeddingSparseBatch"));
-    opBuilder.addInputList(Operands.asOutputs(sampleIndices));
-    opBuilder.addInputList(Operands.asOutputs(embeddingIndices));
-    opBuilder.addInputList(Operands.asOutputs(aggregationWeights));
-    opBuilder.addInput(modeOverride.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, sampleIndices));
+    opBuilder.addInputList(Operands.asOutputs(scope, embeddingIndices));
+    opBuilder.addInputList(Operands.asOutputs(scope, aggregationWeights));
+    opBuilder.addInput(modeOverride.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 e682e0b4ccf..366ca175216 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
@@ -21,7 +21,6 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
@@ -112,12 +111,12 @@ private Options() {
    * @return a new instance of EnqueueTPUEmbeddingSparseTensorBatch
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor & TNumber, V extends Tensor & TNumber> EnqueueTPUEmbeddingSparseTensorBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, List<Long> tableIds, Options... options) {
+  public static <T extends TNumber, U extends TNumber, V extends TNumber> EnqueueTPUEmbeddingSparseTensorBatch create(Scope scope, Iterable<Operand<T>> sampleIndices, Iterable<Operand<U>> embeddingIndices, Iterable<Operand<V>> aggregationWeights, Operand<TString> modeOverride, List<Long> tableIds, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("EnqueueTPUEmbeddingSparseTensorBatch", scope.makeOpName("EnqueueTPUEmbeddingSparseTensorBatch"));
-    opBuilder.addInputList(Operands.asOutputs(sampleIndices));
-    opBuilder.addInputList(Operands.asOutputs(embeddingIndices));
-    opBuilder.addInputList(Operands.asOutputs(aggregationWeights));
-    opBuilder.addInput(modeOverride.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, sampleIndices));
+    opBuilder.addInputList(Operands.asOutputs(scope, embeddingIndices));
+    opBuilder.addInputList(Operands.asOutputs(scope, aggregationWeights));
+    opBuilder.addInput(modeOverride.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] tableIdsArray = new long[tableIds.size()];
     for (int i = 0; i < tableIdsArray.length; ++i) {
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 439716f8f74..e1891dc28b9 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,19 +22,19 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A placeholder op for a value that will be fed into the computation.
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class InfeedDequeue<T extends Tensor> extends RawOp 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.
@@ -45,7 +45,7 @@ public final class InfeedDequeue<T extends Tensor> extends RawOp implements Oper
    * @return a new instance of InfeedDequeue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> InfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape) {
+  public static <T extends TType> InfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("InfeedDequeue", scope.makeOpName("InfeedDequeue"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -61,7 +61,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 35182bdcaf5..3e9fe720ca9 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,17 +25,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Fetches multiple values from infeed as an XLA tuple.
  */
-public final class InfeedDequeueTuple extends RawOp implements Iterable<Operand<Tensor>> {
+public final class InfeedDequeueTuple extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new InfeedDequeueTuple operation.
@@ -71,7 +71,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 61b6f813b57..44b2e09c4ac 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,12 +21,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * An op which feeds a single Tensor value into the computation.
@@ -83,9 +83,9 @@ private Options() {
    * @return a new instance of InfeedEnqueue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> InfeedEnqueue create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> InfeedEnqueue create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("InfeedEnqueue", scope.makeOpName("InfeedEnqueue"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 cdd475a08ae..a95187b48d4 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
@@ -61,7 +61,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static InfeedEnqueuePrelinearizedBuffer create(Scope scope, Operand<?> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("InfeedEnqueuePrelinearizedBuffer", scope.makeOpName("InfeedEnqueuePrelinearizedBuffer"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 c97a792ae7d..c13de09698e 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
@@ -78,7 +78,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static InfeedEnqueueTuple create(Scope scope, Iterable<Operand<?>> inputs, List<Shape> shapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("InfeedEnqueueTuple", scope.makeOpName("InfeedEnqueueTuple"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     Shape[] shapesArray = new Shape[shapes.size()];
     for (int i = 0; i < shapesArray.length; ++i) {
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 1222247d109..24e441e65ee 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
@@ -89,9 +89,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingADAMParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> momenta, Operand<TFloat32> velocities, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingADAMParameters", scope.makeOpName("LoadTPUEmbeddingADAMParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(momenta.asOutput());
-    opBuilder.addInput(velocities.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(momenta.asOutput(scope));
+    opBuilder.addInput(velocities.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 53af351f736..dfce594b639 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
@@ -90,10 +90,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingADAMParametersGradAccumDebug create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> momenta, Operand<TFloat32> velocities, Operand<TFloat32> gradientAccumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingADAMParametersGradAccumDebug", scope.makeOpName("LoadTPUEmbeddingADAMParametersGradAccumDebug"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(momenta.asOutput());
-    opBuilder.addInput(velocities.asOutput());
-    opBuilder.addInput(gradientAccumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(momenta.asOutput(scope));
+    opBuilder.addInput(velocities.asOutput(scope));
+    opBuilder.addInput(gradientAccumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 66e2bc9a3d4..f1e0a2b9987 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
@@ -89,9 +89,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingAdadeltaParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Operand<TFloat32> updates, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingAdadeltaParameters", scope.makeOpName("LoadTPUEmbeddingAdadeltaParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
-    opBuilder.addInput(updates.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 d659eb12ec3..ea54ffd839f 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
@@ -90,10 +90,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingAdadeltaParametersGradAccumDebug create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Operand<TFloat32> updates, Operand<TFloat32> gradientAccumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingAdadeltaParametersGradAccumDebug", scope.makeOpName("LoadTPUEmbeddingAdadeltaParametersGradAccumDebug"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
-    opBuilder.addInput(updates.asOutput());
-    opBuilder.addInput(gradientAccumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
+    opBuilder.addInput(updates.asOutput(scope));
+    opBuilder.addInput(gradientAccumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 80b424e073c..732ef5bf3ad 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
@@ -88,8 +88,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingAdagradParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingAdagradParameters", scope.makeOpName("LoadTPUEmbeddingAdagradParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 de11b50f1f9..533c0969f2d 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
@@ -89,9 +89,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingAdagradParametersGradAccumDebug create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Operand<TFloat32> gradientAccumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingAdagradParametersGradAccumDebug", scope.makeOpName("LoadTPUEmbeddingAdagradParametersGradAccumDebug"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
-    opBuilder.addInput(gradientAccumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
+    opBuilder.addInput(gradientAccumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 b7bbb92fa90..aab7dce85d8 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
@@ -90,10 +90,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingCenteredRMSPropParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> ms, Operand<TFloat32> mom, Operand<TFloat32> mg, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingCenteredRMSPropParameters", scope.makeOpName("LoadTPUEmbeddingCenteredRMSPropParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(mg.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(mg.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 7939230997f..21c901399ad 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
@@ -89,9 +89,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingFTRLParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Operand<TFloat32> linears, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingFTRLParameters", scope.makeOpName("LoadTPUEmbeddingFTRLParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
-    opBuilder.addInput(linears.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
+    opBuilder.addInput(linears.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 38ebb8518bd..b94974daba9 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
@@ -90,10 +90,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingFTRLParametersGradAccumDebug create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Operand<TFloat32> linears, Operand<TFloat32> gradientAccumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingFTRLParametersGradAccumDebug", scope.makeOpName("LoadTPUEmbeddingFTRLParametersGradAccumDebug"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
-    opBuilder.addInput(linears.asOutput());
-    opBuilder.addInput(gradientAccumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
+    opBuilder.addInput(linears.asOutput(scope));
+    opBuilder.addInput(gradientAccumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 7d0f7d014c3..a8af854843c 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
@@ -90,10 +90,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingMDLAdagradLightParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Operand<TFloat32> weights, Operand<TFloat32> benefits, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingMDLAdagradLightParameters", scope.makeOpName("LoadTPUEmbeddingMDLAdagradLightParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
-    opBuilder.addInput(weights.asOutput());
-    opBuilder.addInput(benefits.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
+    opBuilder.addInput(weights.asOutput(scope));
+    opBuilder.addInput(benefits.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 c705213c9a2..a6bb901538b 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
@@ -88,8 +88,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingMomentumParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> momenta, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingMomentumParameters", scope.makeOpName("LoadTPUEmbeddingMomentumParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(momenta.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(momenta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 d774094df05..0bce7416c1d 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
@@ -89,9 +89,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingMomentumParametersGradAccumDebug create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> momenta, Operand<TFloat32> gradientAccumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingMomentumParametersGradAccumDebug", scope.makeOpName("LoadTPUEmbeddingMomentumParametersGradAccumDebug"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(momenta.asOutput());
-    opBuilder.addInput(gradientAccumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(momenta.asOutput(scope));
+    opBuilder.addInput(gradientAccumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 57db2202b99..292b2e0b2cb 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
@@ -88,8 +88,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingProximalAdagradParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingProximalAdagradParameters", scope.makeOpName("LoadTPUEmbeddingProximalAdagradParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 40eec1594f1..b02f665fda9 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
@@ -89,9 +89,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> accumulators, Operand<TFloat32> gradientAccumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug", scope.makeOpName("LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(accumulators.asOutput());
-    opBuilder.addInput(gradientAccumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(accumulators.asOutput(scope));
+    opBuilder.addInput(gradientAccumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 88e2c035ce8..8fa11e449ac 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
@@ -89,9 +89,9 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingRMSPropParameters create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> ms, Operand<TFloat32> mom, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingRMSPropParameters", scope.makeOpName("LoadTPUEmbeddingRMSPropParameters"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 6e79a29f987..e8defb21924 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
@@ -90,10 +90,10 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingRMSPropParametersGradAccumDebug create(Scope scope, Operand<TFloat32> parameters, Operand<TFloat32> ms, Operand<TFloat32> mom, Operand<TFloat32> gradientAccumulators, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingRMSPropParametersGradAccumDebug", scope.makeOpName("LoadTPUEmbeddingRMSPropParametersGradAccumDebug"));
-    opBuilder.addInput(parameters.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(gradientAccumulators.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(gradientAccumulators.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 32b34ea6262..cd2ee1c4e2b 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
@@ -87,7 +87,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static LoadTPUEmbeddingStochasticGradientDescentParameters create(Scope scope, Operand<TFloat32> parameters, Long numShards, Long shardId, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("LoadTPUEmbeddingStochasticGradientDescentParameters", scope.makeOpName("LoadTPUEmbeddingStochasticGradientDescentParameters"));
-    opBuilder.addInput(parameters.asOutput());
+    opBuilder.addInput(parameters.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_shards", numShards);
     opBuilder.setAttr("shard_id", shardId);
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 789fa6f4c29..e33b4f8963e 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Retrieves a single tensor from the computation outfeed.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class OutfeedDequeue<T extends Tensor> extends RawOp implements Operand<T> {
+public final class OutfeedDequeue<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.OutfeedDequeue}
@@ -69,7 +69,7 @@ private Options() {
    * @return a new instance of OutfeedDequeue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> OutfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends TType> OutfeedDequeue<T> create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("OutfeedDequeue", scope.makeOpName("OutfeedDequeue"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -101,7 +101,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 5692bd12a26..b7c2f10fcac 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Retrieve multiple values from the computation outfeed.
@@ -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 RawOp implements Iterable<Operand<Tensor>> {
+public final class OutfeedDequeueTuple extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.OutfeedDequeueTuple}
@@ -112,7 +112,7 @@ public List<Output<?>> outputs() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) outputs.iterator();
   }
   
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 6de5bc99f6c..b84587f1388 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Enqueue a Tensor on the computation outfeed.
@@ -39,9 +39,9 @@ public final class OutfeedEnqueue extends RawOp {
    * @return a new instance of OutfeedEnqueue
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> OutfeedEnqueue create(Scope scope, Operand<T> input) {
+  public static <T extends TType> OutfeedEnqueue create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("OutfeedEnqueue", scope.makeOpName("OutfeedEnqueue"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new OutfeedEnqueue(opBuilder.build());
   }
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 43972c6f64a..94b98014baa 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
@@ -42,7 +42,7 @@ public final class OutfeedEnqueueTuple extends RawOp {
   @Endpoint(describeByClass = true)
   public static OutfeedEnqueueTuple create(Scope scope, Iterable<Operand<?>> inputs) {
     OperationBuilder opBuilder = scope.env().opBuilder("OutfeedEnqueueTuple", scope.makeOpName("OutfeedEnqueueTuple"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new OutfeedEnqueueTuple(opBuilder.build());
   }
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 8784472e132..41ea915a05d 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,17 +22,17 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * An op which linearizes one Tensor value to an opaque variant tensor.
  */
-public final class Prelinearize extends RawOp implements Operand<Tensor> {
+public final class Prelinearize extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.Prelinearize}
@@ -73,9 +73,9 @@ private Options() {
    * @return a new instance of Prelinearize
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Prelinearize create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> Prelinearize create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("Prelinearize", scope.makeOpName("Prelinearize"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -118,8 +118,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 3b175591149..368cf0846a7 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
@@ -22,18 +22,18 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * An op which linearizes multiple Tensor values to an opaque variant tensor.
  */
-public final class PrelinearizeTuple extends RawOp implements Operand<Tensor> {
+public final class PrelinearizeTuple extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.PrelinearizeTuple}
@@ -69,7 +69,7 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static PrelinearizeTuple create(Scope scope, Iterable<Operand<?>> inputs, List<Shape> shapes, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("PrelinearizeTuple", scope.makeOpName("PrelinearizeTuple"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     Shape[] shapesArray = new Shape[shapes.size()];
     for (int i = 0; i < shapesArray.length; ++i) {
@@ -108,8 +108,8 @@ public Output<?> output() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) output;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) output;
   }
   
   private Output<?> output;
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 c98b2b5f7a8..0dbd4f8b712 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
@@ -134,7 +134,7 @@ public Output<TFloat32> parameters() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return parameters;
   }
   
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 87b07cd2b8a..397a46b2ab8 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
@@ -54,8 +54,8 @@ public final class SendTPUEmbeddingGradients extends RawOp {
   @Endpoint(describeByClass = true)
   public static SendTPUEmbeddingGradients create(Scope scope, Iterable<Operand<TFloat32>> inputs, Iterable<Operand<TFloat32>> learningRates, String config) {
     OperationBuilder opBuilder = scope.env().opBuilder("SendTPUEmbeddingGradients", scope.makeOpName("SendTPUEmbeddingGradients"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
-    opBuilder.addInputList(Operands.asOutputs(learningRates));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, learningRates));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("config", config);
     return new SendTPUEmbeddingGradients(opBuilder.build());
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 d9bd22679e3..de0ff62d436 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
@@ -56,7 +56,7 @@ public Output<TString> output() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return output;
   }
   
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 5473e957471..31cae273abf 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
@@ -53,8 +53,8 @@ public final class TPUEmbeddingActivations extends RawOp implements Operand<TFlo
   @Endpoint(describeByClass = true)
   public static TPUEmbeddingActivations create(Scope scope, Operand<TFloat32> embeddingVariable, Operand<TFloat32> slicedActivations, Long tableId, Long lookupId) {
     OperationBuilder opBuilder = scope.env().opBuilder("TPUEmbeddingActivations", scope.makeOpName("TPUEmbeddingActivations"));
-    opBuilder.addInput(embeddingVariable.asOutput());
-    opBuilder.addInput(slicedActivations.asOutput());
+    opBuilder.addInput(embeddingVariable.asOutput(scope));
+    opBuilder.addInput(slicedActivations.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("table_id", tableId);
     opBuilder.setAttr("lookup_id", lookupId);
@@ -68,7 +68,7 @@ public Output<TFloat32> output() {
   }
   
   @Override
-  public Output<TFloat32> asOutput() {
+  public Output<TFloat32> asOutput(Scope scope) {
     return output;
   }
   
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 156f4b779fe..14baa038cfe 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
@@ -57,7 +57,7 @@ public Output<TInt32> deviceOrdinals() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return deviceOrdinals;
   }
   
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 69faf3195bb..62ceaa43e7c 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
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Operands;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Connects N inputs to an N-way replicated TPU computation.
@@ -45,7 +45,7 @@
  * 
  * @param <T> data type for {@code output()} output
  */
-public final class TPUReplicatedInput<T extends Tensor> extends RawOp implements Operand<T> {
+public final class TPUReplicatedInput<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.tpu.TPUReplicatedInput}
@@ -84,9 +84,9 @@ private Options() {
    * @return a new instance of TPUReplicatedInput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TPUReplicatedInput<T> create(Scope scope, Iterable<Operand<T>> inputs, Options... options) {
+  public static <T extends TType> TPUReplicatedInput<T> create(Scope scope, Iterable<Operand<T>> inputs, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("TPUReplicatedInput", scope.makeOpName("TPUReplicatedInput"));
-    opBuilder.addInputList(Operands.asOutputs(inputs));
+    opBuilder.addInputList(Operands.asOutputs(scope, inputs));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -122,7 +122,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 06b0a67c110..6283aa291dc 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,11 +24,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Connects N outputs from an N-way replicated TPU computation.
@@ -45,7 +45,7 @@
  * 
  * @param <T> data type for {@code outputs()} output
  */
-public final class TPUReplicatedOutput<T extends Tensor> extends RawOp 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.
@@ -56,9 +56,9 @@ public final class TPUReplicatedOutput<T extends Tensor> extends RawOp implement
    * @return a new instance of TPUReplicatedOutput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TPUReplicatedOutput<T> create(Scope scope, Operand<T> input, Long numReplicas) {
+  public static <T extends TType> TPUReplicatedOutput<T> create(Scope scope, Operand<T> input, Long numReplicas) {
     OperationBuilder opBuilder = scope.env().opBuilder("TPUReplicatedOutput", scope.makeOpName("TPUReplicatedOutput"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("num_replicas", numReplicas);
     return new TPUReplicatedOutput<T>(opBuilder.build());
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 bb35afe9d09..2cf6d4a7680 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
@@ -45,7 +45,7 @@ public final class WorkerHeartbeat extends RawOp implements Operand<TString> {
   @Endpoint(describeByClass = true)
   public static WorkerHeartbeat create(Scope scope, Operand<TString> request) {
     OperationBuilder opBuilder = scope.env().opBuilder("WorkerHeartbeat", scope.makeOpName("WorkerHeartbeat"));
-    opBuilder.addInput(request.asOutput());
+    opBuilder.addInput(request.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new WorkerHeartbeat(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TString> response() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return response;
   }
   
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 275d0b3f949..891b4cfc669 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies a gradient to a given accumulator.
@@ -46,11 +46,11 @@ public final class AccumulatorApplyGradient extends RawOp {
    * @return a new instance of AccumulatorApplyGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<T> gradient) {
+  public static <T extends TType> AccumulatorApplyGradient create(Scope scope, Operand<TString> handle, Operand<TInt64> localStep, Operand<T> gradient) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulatorApplyGradient", scope.makeOpName("AccumulatorApplyGradient"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(localStep.asOutput());
-    opBuilder.addInput(gradient.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(localStep.asOutput(scope));
+    opBuilder.addInput(gradient.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AccumulatorApplyGradient(opBuilder.build());
   }
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 8146deccf7d..51c24cecefb 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
@@ -44,7 +44,7 @@ public final class AccumulatorNumAccumulated extends RawOp implements Operand<TI
   @Endpoint(describeByClass = true)
   public static AccumulatorNumAccumulated create(Scope scope, Operand<TString> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulatorNumAccumulated", scope.makeOpName("AccumulatorNumAccumulated"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AccumulatorNumAccumulated(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<TInt32> numAccumulated() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return numAccumulated;
   }
   
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 747fcc6b123..dcfb5fad10d 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
@@ -47,8 +47,8 @@ public final class AccumulatorSetGlobalStep extends RawOp {
   @Endpoint(describeByClass = true)
   public static AccumulatorSetGlobalStep create(Scope scope, Operand<TString> handle, Operand<TInt64> newGlobalStep) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulatorSetGlobalStep", scope.makeOpName("AccumulatorSetGlobalStep"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(newGlobalStep.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(newGlobalStep.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new AccumulatorSetGlobalStep(opBuilder.build());
   }
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 af651a85bab..58a8f0ab50f 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Extracts the average gradient in the given ConditionalAccumulator.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code average()} output
  */
 @Operator(group = "train")
-public final class AccumulatorTakeGradient<T extends Tensor> extends RawOp 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.
@@ -55,10 +55,10 @@ public final class AccumulatorTakeGradient<T extends Tensor> extends RawOp imple
    * @return a new instance of AccumulatorTakeGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> AccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
+  public static <T extends TType> AccumulatorTakeGradient<T> create(Scope scope, Operand<TString> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("AccumulatorTakeGradient", scope.makeOpName("AccumulatorTakeGradient"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(numRequired.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(numRequired.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new AccumulatorTakeGradient<T>(opBuilder.build());
@@ -72,7 +72,7 @@ public Output<T> average() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return average;
   }
   
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 3c5c464909c..6b67ca4a071 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AdaMax algorithm.
@@ -36,7 +36,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class ApplyAdaMax<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyAdaMax<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdaMax}
@@ -76,17 +76,17 @@ private Options() {
    * @return a new instance of ApplyAdaMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyAdaMax<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyAdaMax<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdaMax", scope.makeOpName("ApplyAdaMax"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(beta1Power.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(beta1.asOutput());
-    opBuilder.addInput(beta2.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(beta1Power.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(beta1.asOutput(scope));
+    opBuilder.addInput(beta2.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -115,7 +115,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 cde20b21955..e6440090d85 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adadelta scheme.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdadelta<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyAdadelta<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdadelta}
@@ -75,15 +75,15 @@ private Options() {
    * @return a new instance of ApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdadelta", scope.makeOpName("ApplyAdadelta"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(accumUpdate.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(accumUpdate.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -111,7 +111,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 7986b5c21d8..ac5c5a95c47 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adagrad scheme.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagrad}
@@ -80,12 +80,12 @@ private Options() {
    * @return a new instance of ApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdagrad", scope.makeOpName("ApplyAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -124,7 +124,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 01620ddc4c6..3afa0963bcb 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the proximal adagrad scheme.
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdagradDa<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyAdagradDa<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagradDa}
@@ -72,16 +72,16 @@ private Options() {
    * @return a new instance of ApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends TType> ApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdagradDA", scope.makeOpName("ApplyAdagradDa"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(gradientAccumulator.asOutput());
-    opBuilder.addInput(gradientSquaredAccumulator.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(globalStep.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(gradientAccumulator.asOutput(scope));
+    opBuilder.addInput(gradientSquaredAccumulator.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(globalStep.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -109,7 +109,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 d3053291e23..43cce745f1d 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adagrad scheme.
@@ -35,7 +35,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class ApplyAdagradV2<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyAdagradV2<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdagradV2}
@@ -80,13 +80,13 @@ private Options() {
    * @return a new instance of ApplyAdagradV2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyAdagradV2<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyAdagradV2<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdagradV2", scope.makeOpName("ApplyAdagradV2"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -125,7 +125,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 6f5cb1b5f0a..e27648cf317 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Adam algorithm.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAdam<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyAdam<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAdam}
@@ -88,18 +88,18 @@ private Options() {
    * @return a new instance of ApplyAdam
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyAdam<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyAdam<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAdam", scope.makeOpName("ApplyAdam"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(beta1Power.asOutput());
-    opBuilder.addInput(beta2Power.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(beta1.asOutput());
-    opBuilder.addInput(beta2.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(beta1Power.asOutput(scope));
+    opBuilder.addInput(beta2Power.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(beta1.asOutput(scope));
+    opBuilder.addInput(beta2.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -138,7 +138,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 2d816ff8f5f..275c1eb9bda 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyAddSign<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyAddSign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyAddSign}
@@ -75,15 +75,15 @@ private Options() {
    * @return a new instance of ApplyAddSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyAddSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyAddSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyAddSign", scope.makeOpName("ApplyAddSign"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(signDecay.asOutput());
-    opBuilder.addInput(beta.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(signDecay.asOutput(scope));
+    opBuilder.addInput(beta.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -112,7 +112,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 52ed6d9805b..438b25694c8 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -52,7 +52,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyCenteredRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyCenteredRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyCenteredRmsProp}
@@ -92,17 +92,17 @@ private Options() {
    * @return a new instance of ApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyCenteredRMSProp", scope.makeOpName("ApplyCenteredRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(mg.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(mg.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -131,7 +131,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 130da063347..8d6f39ef1c2 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Ftrl-proximal scheme.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyFtrl<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyFtrl<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyFtrl}
@@ -81,17 +81,17 @@ private Options() {
    * @return a new instance of ApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends TType> ApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyFtrlV2", scope.makeOpName("ApplyFtrl"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(linear.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(l2Shrinkage.asOutput());
-    opBuilder.addInput(lrPower.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(linear.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(l2Shrinkage.asOutput(scope));
+    opBuilder.addInput(lrPower.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -120,7 +120,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 e0311439aca..9b54c9009eb 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' by subtracting 'alpha' * 'delta' from it.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyGradientDescent<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyGradientDescent<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyGradientDescent}
@@ -66,11 +66,11 @@ private Options() {
    * @return a new instance of ApplyGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> delta, Options... options) {
+  public static <T extends TType> ApplyGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyGradientDescent", scope.makeOpName("ApplyGradientDescent"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(delta.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(delta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -98,7 +98,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 8814aea9d82..fefc5801355 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the momentum scheme.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyMomentum<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyMomentum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyMomentum}
@@ -85,13 +85,13 @@ private Options() {
    * @return a new instance of ApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
+  public static <T extends TType> ApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyMomentum", scope.makeOpName("ApplyMomentum"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(momentum.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -132,7 +132,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 176797e65a5..b3adbbd785f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyPowerSign<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyPowerSign<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyPowerSign}
@@ -75,15 +75,15 @@ private Options() {
    * @return a new instance of ApplyPowerSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyPowerSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyPowerSign<T> create(Scope scope, Operand<T> var, Operand<T> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyPowerSign", scope.makeOpName("ApplyPowerSign"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(logbase.asOutput());
-    opBuilder.addInput(signDecay.asOutput());
-    opBuilder.addInput(beta.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(logbase.asOutput(scope));
+    opBuilder.addInput(signDecay.asOutput(scope));
+    opBuilder.addInput(beta.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -112,7 +112,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 5eb77848587..a1272ba2c6f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyProximalAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyProximalAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyProximalAdagrad}
@@ -73,14 +73,14 @@ private Options() {
    * @return a new instance of ApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyProximalAdagrad", scope.makeOpName("ApplyProximalAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -108,7 +108,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 2845d9dcf35..5bb9f03a96a 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' as FOBOS algorithm with fixed learning rate.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyProximalGradientDescent<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyProximalGradientDescent<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyProximalGradientDescent}
@@ -71,13 +71,13 @@ private Options() {
    * @return a new instance of ApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
+  public static <T extends TType> ApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyProximalGradientDescent", scope.makeOpName("ApplyProximalGradientDescent"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(delta.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(delta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -105,7 +105,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 c62b03b3fb9..3ff62505700 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class ApplyRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ApplyRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ApplyRmsProp}
@@ -83,16 +83,16 @@ private Options() {
    * @return a new instance of ApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ApplyRMSProp", scope.makeOpName("ApplyRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -121,7 +121,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 898d26681e6..624112b081f 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Multiplies slices of two tensors in batches.
@@ -57,7 +57,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class BatchMatMul<T extends Tensor> extends RawOp implements Operand<T> {
+public final class BatchMatMul<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.BatchMatMul}
@@ -97,10 +97,10 @@ private Options() {
    * @return a new instance of BatchMatMul
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> BatchMatMul<T> create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
+  public static <T extends TType> BatchMatMul<T> create(Scope scope, Operand<T> x, Operand<T> y, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("BatchMatMulV2", scope.makeOpName("BatchMatMul"));
-    opBuilder.addInput(x.asOutput());
-    opBuilder.addInput(y.asOutput());
+    opBuilder.addInput(x.asOutput(scope));
+    opBuilder.addInput(y.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -137,7 +137,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 c8cf08b77f3..56eebe5a838 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,13 +22,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * A conditional accumulator for aggregating gradients.
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of ConditionalAccumulator
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends TType> ConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ConditionalAccumulator", scope.makeOpName("ConditionalAccumulator"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -144,7 +144,7 @@ public Output<TString> handle() {
   }
   
   @Override
-  public Output<TString> asOutput() {
+  public Output<TString> asOutput(Scope scope) {
     return handle;
   }
   
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 f1d4fb5d792..57770bd784b 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
@@ -98,8 +98,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static GenerateVocabRemapping create(Scope scope, Operand<TString> newVocabFile, Operand<TString> oldVocabFile, Long newVocabOffset, Long numNewVocab, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("GenerateVocabRemapping", scope.makeOpName("GenerateVocabRemapping"));
-    opBuilder.addInput(newVocabFile.asOutput());
-    opBuilder.addInput(oldVocabFile.asOutput());
+    opBuilder.addInput(newVocabFile.asOutput(scope));
+    opBuilder.addInput(oldVocabFile.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("new_vocab_offset", newVocabOffset);
     opBuilder.setAttr("num_new_vocab", numNewVocab);
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 7807178f138..7f1f1491927 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
@@ -73,8 +73,8 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static MergeV2Checkpoints create(Scope scope, Operand<TString> checkpointPrefixes, Operand<TString> destinationPrefix, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("MergeV2Checkpoints", scope.makeOpName("MergeV2Checkpoints"));
-    opBuilder.addInput(checkpointPrefixes.asOutput());
-    opBuilder.addInput(destinationPrefix.asOutput());
+    opBuilder.addInput(checkpointPrefixes.asOutput(scope));
+    opBuilder.addInput(destinationPrefix.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 1a625589a1d..89699a34000 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
@@ -50,11 +50,11 @@ public final class NegTrain extends RawOp {
   @Endpoint(describeByClass = true)
   public static NegTrain create(Scope scope, Operand<TFloat32> wIn, Operand<TFloat32> wOut, Operand<TInt32> examples, Operand<TInt32> labels, Operand<TFloat32> lr, List<Long> vocabCount, Long numNegativeSamples) {
     OperationBuilder opBuilder = scope.env().opBuilder("NegTrain", scope.makeOpName("NegTrain"));
-    opBuilder.addInput(wIn.asOutput());
-    opBuilder.addInput(wOut.asOutput());
-    opBuilder.addInput(examples.asOutput());
-    opBuilder.addInput(labels.asOutput());
-    opBuilder.addInput(lr.asOutput());
+    opBuilder.addInput(wIn.asOutput(scope));
+    opBuilder.addInput(wOut.asOutput(scope));
+    opBuilder.addInput(examples.asOutput(scope));
+    opBuilder.addInput(labels.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     long[] vocabCountArray = new long[vocabCount.size()];
     for (int i = 0; i < vocabCountArray.length; ++i) {
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 af24d35e0eb..6f3c0dc0dee 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,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * An identity op that triggers an error if a gradient is requested.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class PreventGradient<T extends Tensor> extends RawOp implements Operand<T> {
+public final class PreventGradient<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.PreventGradient}
@@ -72,9 +72,9 @@ private Options() {
    * @return a new instance of PreventGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> PreventGradient<T> create(Scope scope, Operand<T> input, Options... options) {
+  public static <T extends TType> PreventGradient<T> create(Scope scope, Operand<T> input, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("PreventGradient", scope.makeOpName("PreventGradient"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -102,7 +102,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
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 42f7fafabf8..887f2352f20 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Applies a gradient to a given accumulator.
@@ -44,11 +44,11 @@ public final class ResourceAccumulatorApplyGradient extends RawOp {
    * @return a new instance of ResourceAccumulatorApplyGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceAccumulatorApplyGradient create(Scope scope, Operand<?> handle, Operand<TInt64> localStep, Operand<T> gradient) {
+  public static <T extends TType> ResourceAccumulatorApplyGradient create(Scope scope, Operand<?> handle, Operand<TInt64> localStep, Operand<T> gradient) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceAccumulatorApplyGradient", scope.makeOpName("ResourceAccumulatorApplyGradient"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(localStep.asOutput());
-    opBuilder.addInput(gradient.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(localStep.asOutput(scope));
+    opBuilder.addInput(gradient.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceAccumulatorApplyGradient(opBuilder.build());
   }
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 3ec9d5dc02c..8875a603f0c 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
@@ -42,7 +42,7 @@ public final class ResourceAccumulatorNumAccumulated extends RawOp implements Op
   @Endpoint(describeByClass = true)
   public static ResourceAccumulatorNumAccumulated create(Scope scope, Operand<?> handle) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceAccumulatorNumAccumulated", scope.makeOpName("ResourceAccumulatorNumAccumulated"));
-    opBuilder.addInput(handle.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceAccumulatorNumAccumulated(opBuilder.build());
   }
@@ -55,7 +55,7 @@ public Output<TInt32> numAccumulated() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return numAccumulated;
   }
   
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 d7f8261bc11..84895e0e41f 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
@@ -45,8 +45,8 @@ public final class ResourceAccumulatorSetGlobalStep extends RawOp {
   @Endpoint(describeByClass = true)
   public static ResourceAccumulatorSetGlobalStep create(Scope scope, Operand<?> handle, Operand<TInt64> newGlobalStep) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceAccumulatorSetGlobalStep", scope.makeOpName("ResourceAccumulatorSetGlobalStep"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(newGlobalStep.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(newGlobalStep.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ResourceAccumulatorSetGlobalStep(opBuilder.build());
   }
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 57790d28a48..f0fbf695e24 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Extracts the average gradient in the given ConditionalAccumulator.
@@ -40,7 +40,7 @@
  * 
  * @param <T> data type for {@code average()} output
  */
-public final class ResourceAccumulatorTakeGradient<T extends Tensor> extends RawOp 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.
@@ -53,10 +53,10 @@ public final class ResourceAccumulatorTakeGradient<T extends Tensor> extends Raw
    * @return a new instance of ResourceAccumulatorTakeGradient
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceAccumulatorTakeGradient<T> create(Scope scope, Operand<?> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
+  public static <T extends TType> ResourceAccumulatorTakeGradient<T> create(Scope scope, Operand<?> handle, Operand<TInt32> numRequired, DataType<T> dtype) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceAccumulatorTakeGradient", scope.makeOpName("ResourceAccumulatorTakeGradient"));
-    opBuilder.addInput(handle.asOutput());
-    opBuilder.addInput(numRequired.asOutput());
+    opBuilder.addInput(handle.asOutput(scope));
+    opBuilder.addInput(numRequired.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
     return new ResourceAccumulatorTakeGradient<T>(opBuilder.build());
@@ -70,7 +70,7 @@ public Output<T> average() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return average;
   }
   
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 d23e9fe9654..2b432ce45bf 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AdaMax algorithm.
@@ -73,17 +73,17 @@ private Options() {
    * @return a new instance of ResourceApplyAdaMax
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyAdaMax create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyAdaMax create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdaMax", scope.makeOpName("ResourceApplyAdaMax"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(beta1Power.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(beta1.asOutput());
-    opBuilder.addInput(beta2.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(beta1Power.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(beta1.asOutput(scope));
+    opBuilder.addInput(beta2.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 61154791d29..89fb64dcaab 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adadelta scheme.
@@ -72,15 +72,15 @@ private Options() {
    * @return a new instance of ResourceApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdadelta", scope.makeOpName("ResourceApplyAdadelta"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(accumUpdate.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(accumUpdate.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 b629e1b4106..2e9fe8f35fa 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the adagrad scheme.
@@ -77,13 +77,13 @@ private Options() {
    * @return a new instance of ResourceApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdagradV2", scope.makeOpName("ResourceApplyAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 b636b6b4473..bdcaa701119 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the proximal adagrad scheme.
@@ -69,16 +69,16 @@ private Options() {
    * @return a new instance of ResourceApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends TType> ResourceApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdagradDA", scope.makeOpName("ResourceApplyAdagradDa"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(gradientAccumulator.asOutput());
-    opBuilder.addInput(gradientSquaredAccumulator.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(globalStep.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(gradientAccumulator.asOutput(scope));
+    opBuilder.addInput(gradientSquaredAccumulator.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(globalStep.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 50e2aa8d21b..4cdd4f66b53 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Adam algorithm.
@@ -85,18 +85,18 @@ private Options() {
    * @return a new instance of ResourceApplyAdam
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyAdam create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyAdam create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdam", scope.makeOpName("ResourceApplyAdam"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(beta1Power.asOutput());
-    opBuilder.addInput(beta2Power.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(beta1.asOutput());
-    opBuilder.addInput(beta2.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(beta1Power.asOutput(scope));
+    opBuilder.addInput(beta2Power.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(beta1.asOutput(scope));
+    opBuilder.addInput(beta2.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 c081212e9eb..341e1aba22e 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Adam algorithm.
@@ -78,19 +78,19 @@ private Options() {
    * @return a new instance of ResourceApplyAdamWithAmsgrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyAdamWithAmsgrad create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyAdamWithAmsgrad create(Scope scope, Operand<?> var, Operand<?> m, Operand<?> v, Operand<?> vhat, Operand<T> beta1Power, Operand<T> beta2Power, Operand<T> lr, Operand<T> beta1, Operand<T> beta2, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAdamWithAmsgrad", scope.makeOpName("ResourceApplyAdamWithAmsgrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(v.asOutput());
-    opBuilder.addInput(vhat.asOutput());
-    opBuilder.addInput(beta1Power.asOutput());
-    opBuilder.addInput(beta2Power.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(beta1.asOutput());
-    opBuilder.addInput(beta2.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(v.asOutput(scope));
+    opBuilder.addInput(vhat.asOutput(scope));
+    opBuilder.addInput(beta1Power.asOutput(scope));
+    opBuilder.addInput(beta2Power.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(beta1.asOutput(scope));
+    opBuilder.addInput(beta2.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 6bfcd2914cf..b1fa4733582 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -72,15 +72,15 @@ private Options() {
    * @return a new instance of ResourceApplyAddSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyAddSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyAddSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> alpha, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyAddSign", scope.makeOpName("ResourceApplyAddSign"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(signDecay.asOutput());
-    opBuilder.addInput(beta.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(signDecay.asOutput(scope));
+    opBuilder.addInput(beta.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 f1edd1a6ad1..397b75b8a3d 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -89,17 +89,17 @@ private Options() {
    * @return a new instance of ResourceApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyCenteredRMSProp", scope.makeOpName("ResourceApplyCenteredRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(mg.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(mg.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 5bc0109d1f1..18a7ee6c18d 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the Ftrl-proximal scheme.
@@ -78,17 +78,17 @@ private Options() {
    * @return a new instance of ResourceApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends TType> ResourceApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyFtrlV2", scope.makeOpName("ResourceApplyFtrl"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(linear.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(l2Shrinkage.asOutput());
-    opBuilder.addInput(lrPower.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(linear.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(l2Shrinkage.asOutput(scope));
+    opBuilder.addInput(lrPower.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 014a3368830..0feb5017e3b 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' by subtracting 'alpha' * 'delta' from it.
@@ -63,11 +63,11 @@ private Options() {
    * @return a new instance of ResourceApplyGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> delta, Options... options) {
+  public static <T extends TType> ResourceApplyGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyGradientDescent", scope.makeOpName("ResourceApplyGradientDescent"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(delta.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(delta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 f98c43d6e7f..a4bd5f2d298 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the momentum scheme.
@@ -82,13 +82,13 @@ private Options() {
    * @return a new instance of ResourceApplyKerasMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
+  public static <T extends TType> ResourceApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyKerasMomentum", scope.makeOpName("ResourceApplyKerasMomentum"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(momentum.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 8580aae6b55..5d1c21933c4 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the momentum scheme. Set use_nesterov = True if you
@@ -82,13 +82,13 @@ private Options() {
    * @return a new instance of ResourceApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
+  public static <T extends TType> ResourceApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyMomentum", scope.makeOpName("ResourceApplyMomentum"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(momentum.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 738a507d64d..eb8133ecc2a 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the AddSign update.
@@ -72,15 +72,15 @@ private Options() {
    * @return a new instance of ResourceApplyPowerSign
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyPowerSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyPowerSign create(Scope scope, Operand<?> var, Operand<?> m, Operand<T> lr, Operand<T> logbase, Operand<T> signDecay, Operand<T> beta, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyPowerSign", scope.makeOpName("ResourceApplyPowerSign"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(m.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(logbase.asOutput());
-    opBuilder.addInput(signDecay.asOutput());
-    opBuilder.addInput(beta.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(m.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(logbase.asOutput(scope));
+    opBuilder.addInput(signDecay.asOutput(scope));
+    opBuilder.addInput(beta.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 dac94fe5247..6539acddb36 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
@@ -70,14 +70,14 @@ private Options() {
    * @return a new instance of ResourceApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyProximalAdagrad", scope.makeOpName("ResourceApplyProximalAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 1417a6a4608..ca5fa1d5cf9 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' as FOBOS algorithm with fixed learning rate.
@@ -68,13 +68,13 @@ private Options() {
    * @return a new instance of ResourceApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
+  public static <T extends TType> ResourceApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> delta, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyProximalGradientDescent", scope.makeOpName("ResourceApplyProximalGradientDescent"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(delta.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(delta.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 18c61ef913f..14c20050390 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,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -80,16 +80,16 @@ private Options() {
    * @return a new instance of ResourceApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
+  public static <T extends TType> ResourceApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceApplyRMSProp", scope.makeOpName("ResourceApplyRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 cea45b1773f..b60cb1e845d 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * A conditional accumulator for aggregating gradients.
@@ -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 RawOp implements Operand<Tensor> {
+public final class ResourceConditionalAccumulator extends RawOp implements Operand<TType> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.ResourceConditionalAccumulator}
@@ -92,7 +92,7 @@ private Options() {
    * @return a new instance of ResourceConditionalAccumulator
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ResourceConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
+  public static <T extends TType> ResourceConditionalAccumulator create(Scope scope, DataType<T> dtype, Shape shape, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceConditionalAccumulator", scope.makeOpName("ResourceConditionalAccumulator"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -145,8 +145,8 @@ public Output<?> handle() {
   
   @Override
   @SuppressWarnings("unchecked")
-  public Output<Tensor> asOutput() {
-    return (Output<Tensor>) handle;
+  public Output<TType> asOutput(Scope scope) {
+    return (Output<TType>) handle;
   }
   
   private Output<?> handle;
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 1f228220913..d2390b3ca55 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * var: Should be from a Variable().
@@ -69,16 +69,16 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdadelta create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdadelta", scope.makeOpName("ResourceSparseApplyAdadelta"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(accumUpdate.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(accumUpdate.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 92a826eac98..bbf2e405616 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
@@ -80,13 +80,13 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdagrad", scope.makeOpName("ResourceSparseApplyAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 f7864e0354d..385ec73f022 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,13 +20,13 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
@@ -71,17 +71,17 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdagradDa create(Scope scope, Operand<?> var, Operand<?> gradientAccumulator, Operand<?> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdagradDA", scope.makeOpName("ResourceSparseApplyAdagradDa"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(gradientAccumulator.asOutput());
-    opBuilder.addInput(gradientSquaredAccumulator.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(globalStep.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(gradientAccumulator.asOutput(scope));
+    opBuilder.addInput(gradientSquaredAccumulator.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(globalStep.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 0fa87d30eaa..5cf557bf87c 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
@@ -80,14 +80,14 @@ private Options() {
    * @return a new instance of ResourceSparseApplyAdagradV2
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyAdagradV2 create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyAdagradV2 create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyAdagradV2", scope.makeOpName("ResourceSparseApplyAdagradV2"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 8ac7e4f256e..db563bf1865 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -89,18 +89,18 @@ private Options() {
    * @return a new instance of ResourceSparseApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyCenteredRmsProp create(Scope scope, Operand<?> var, Operand<?> mg, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyCenteredRMSProp", scope.makeOpName("ResourceSparseApplyCenteredRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(mg.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(mg.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 3f5dd1f689c..d0c048e1200 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' according to the Ftrl-proximal scheme.
@@ -81,18 +81,18 @@ private Options() {
    * @return a new instance of ResourceSparseApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyFtrl create(Scope scope, Operand<?> var, Operand<?> accum, Operand<?> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyFtrlV2", scope.makeOpName("ResourceSparseApplyFtrl"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(linear.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(l2Shrinkage.asOutput());
-    opBuilder.addInput(lrPower.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(linear.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(l2Shrinkage.asOutput(scope));
+    opBuilder.addInput(lrPower.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 81039e15944..a55126e0ccb 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the momentum scheme.
@@ -86,14 +86,14 @@ private Options() {
    * @return a new instance of ResourceSparseApplyKerasMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyKerasMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyKerasMomentum", scope.makeOpName("ResourceSparseApplyKerasMomentum"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(momentum.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 20400243d25..979f379ef19 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the momentum scheme.
@@ -86,14 +86,14 @@ private Options() {
    * @return a new instance of ResourceSparseApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyMomentum create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyMomentum", scope.makeOpName("ResourceSparseApplyMomentum"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(momentum.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 442dd8c2c78..cf1764e4402 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
@@ -74,15 +74,15 @@ private Options() {
    * @return a new instance of ResourceSparseApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyProximalAdagrad create(Scope scope, Operand<?> var, Operand<?> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyProximalAdagrad", scope.makeOpName("ResourceSparseApplyProximalAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 f6ba86b72d4..4ebbb87537b 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update '*var' as FOBOS algorithm with fixed learning rate.
@@ -71,14 +71,14 @@ private Options() {
    * @return a new instance of ResourceSparseApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyProximalGradientDescent create(Scope scope, Operand<?> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyProximalGradientDescent", scope.makeOpName("ResourceSparseApplyProximalGradientDescent"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 4ee32e76a21..cb416b14794 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,12 +20,12 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -82,17 +82,17 @@ private Options() {
    * @return a new instance of ResourceSparseApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> ResourceSparseApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> ResourceSparseApplyRmsProp create(Scope scope, Operand<?> var, Operand<?> ms, Operand<?> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("ResourceSparseApplyRMSProp", scope.makeOpName("ResourceSparseApplyRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
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 6377fc831d2..01519516e52 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,12 +25,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Restores tensors from a V2 checkpoint.
@@ -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 RawOp implements Iterable<Operand<Tensor>> {
+public final class Restore extends RawOp implements Iterable<Operand<TType>> {
   
   /**
    * Factory method to create a class wrapping a new Restore operation.
@@ -67,9 +67,9 @@ public final class Restore extends RawOp implements Iterable<Operand<Tensor>> {
   @Endpoint(describeByClass = true)
   public static Restore create(Scope scope, Operand<TString> prefix, Operand<TString> tensorNames, Operand<TString> shapeAndSlices, List<DataType<?>> dtypes) {
     OperationBuilder opBuilder = scope.env().opBuilder("RestoreV2", scope.makeOpName("Restore"));
-    opBuilder.addInput(prefix.asOutput());
-    opBuilder.addInput(tensorNames.asOutput());
-    opBuilder.addInput(shapeAndSlices.asOutput());
+    opBuilder.addInput(prefix.asOutput(scope));
+    opBuilder.addInput(tensorNames.asOutput(scope));
+    opBuilder.addInput(shapeAndSlices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     DataType[] dtypesArray = new DataType[dtypes.size()];
     for (int i = 0; i < dtypesArray.length; ++i) {
@@ -89,7 +89,7 @@ public List<Output<?>> tensors() {
   
   @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
-  public Iterator<Operand<Tensor>> iterator() {
+  public Iterator<Operand<TType>> iterator() {
     return (Iterator) tensors.iterator();
   }
   
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 3aeee88ef68..13f9046ec19 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,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TString;
+import org.tensorflow.types.family.TType;
 
 /**
  * Restores a tensor from checkpoint files.
@@ -42,7 +42,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator(group = "train")
-public final class RestoreSlice<T extends Tensor> extends RawOp implements Operand<T> {
+public final class RestoreSlice<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.RestoreSlice}
@@ -79,11 +79,11 @@ private Options() {
    * @return a new instance of RestoreSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> RestoreSlice<T> create(Scope scope, Operand<TString> filePattern, Operand<TString> tensorName, Operand<TString> shapeAndSlice, DataType<T> dt, Options... options) {
+  public static <T extends TType> RestoreSlice<T> create(Scope scope, Operand<TString> filePattern, Operand<TString> tensorName, Operand<TString> shapeAndSlice, DataType<T> dt, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("RestoreSlice", scope.makeOpName("RestoreSlice"));
-    opBuilder.addInput(filePattern.asOutput());
-    opBuilder.addInput(tensorName.asOutput());
-    opBuilder.addInput(shapeAndSlice.asOutput());
+    opBuilder.addInput(filePattern.asOutput(scope));
+    opBuilder.addInput(tensorName.asOutput(scope));
+    opBuilder.addInput(shapeAndSlice.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dt", dt);
     if (options != null) {
@@ -112,7 +112,7 @@ public Output<T> tensor() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return tensor;
   }
   
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 b33f1c1c33b..6a1e7901c26 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
@@ -52,10 +52,10 @@ public final class Save extends RawOp {
   @Endpoint(describeByClass = true)
   public static Save create(Scope scope, Operand<TString> prefix, Operand<TString> tensorNames, Operand<TString> shapeAndSlices, Iterable<Operand<?>> tensors) {
     OperationBuilder opBuilder = scope.env().opBuilder("SaveV2", scope.makeOpName("Save"));
-    opBuilder.addInput(prefix.asOutput());
-    opBuilder.addInput(tensorNames.asOutput());
-    opBuilder.addInput(shapeAndSlices.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(tensors));
+    opBuilder.addInput(prefix.asOutput(scope));
+    opBuilder.addInput(tensorNames.asOutput(scope));
+    opBuilder.addInput(shapeAndSlices.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, tensors));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Save(opBuilder.build());
   }
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 25c91540ede..e56422d95c5 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
@@ -78,10 +78,10 @@ public final class SaveSlices extends RawOp {
   @Endpoint(describeByClass = true)
   public static SaveSlices create(Scope scope, Operand<TString> filename, Operand<TString> tensorNames, Operand<TString> shapesAndSlices, Iterable<Operand<?>> data) {
     OperationBuilder opBuilder = scope.env().opBuilder("SaveSlices", scope.makeOpName("SaveSlices"));
-    opBuilder.addInput(filename.asOutput());
-    opBuilder.addInput(tensorNames.asOutput());
-    opBuilder.addInput(shapesAndSlices.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(data));
+    opBuilder.addInput(filename.asOutput(scope));
+    opBuilder.addInput(tensorNames.asOutput(scope));
+    opBuilder.addInput(shapesAndSlices.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, data));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SaveSlices(opBuilder.build());
   }
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 b5629b59b88..0b1d7631aff 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
@@ -44,7 +44,7 @@ public final class SdcaFprint extends RawOp implements Operand<TInt64> {
   @Endpoint(describeByClass = true)
   public static SdcaFprint create(Scope scope, Operand<TString> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("SdcaFprint", scope.makeOpName("SdcaFprint"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new SdcaFprint(opBuilder.build());
   }
@@ -58,7 +58,7 @@ public Output<TInt64> output() {
   }
   
   @Override
-  public Output<TInt64> asOutput() {
+  public Output<TInt64> asOutput(Scope scope) {
     return output;
   }
   
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 9cf443dc4d8..17f6a080b34 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
@@ -106,16 +106,16 @@ private Options() {
   @Endpoint(describeByClass = true)
   public static SdcaOptimizer create(Scope scope, Iterable<Operand<TInt64>> sparseExampleIndices, Iterable<Operand<TInt64>> sparseFeatureIndices, Iterable<Operand<TFloat32>> sparseFeatureValues, Iterable<Operand<TFloat32>> denseFeatures, Operand<TFloat32> exampleWeights, Operand<TFloat32> exampleLabels, Iterable<Operand<TInt64>> sparseIndices, Iterable<Operand<TFloat32>> sparseWeights, Iterable<Operand<TFloat32>> denseWeights, Operand<TFloat32> exampleStateData, String lossType, Float l1, Float l2, Long numLossPartitions, Long numInnerIterations, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SdcaOptimizerV2", scope.makeOpName("SdcaOptimizer"));
-    opBuilder.addInputList(Operands.asOutputs(sparseExampleIndices));
-    opBuilder.addInputList(Operands.asOutputs(sparseFeatureIndices));
-    opBuilder.addInputList(Operands.asOutputs(sparseFeatureValues));
-    opBuilder.addInputList(Operands.asOutputs(denseFeatures));
-    opBuilder.addInput(exampleWeights.asOutput());
-    opBuilder.addInput(exampleLabels.asOutput());
-    opBuilder.addInputList(Operands.asOutputs(sparseIndices));
-    opBuilder.addInputList(Operands.asOutputs(sparseWeights));
-    opBuilder.addInputList(Operands.asOutputs(denseWeights));
-    opBuilder.addInput(exampleStateData.asOutput());
+    opBuilder.addInputList(Operands.asOutputs(scope, sparseExampleIndices));
+    opBuilder.addInputList(Operands.asOutputs(scope, sparseFeatureIndices));
+    opBuilder.addInputList(Operands.asOutputs(scope, sparseFeatureValues));
+    opBuilder.addInputList(Operands.asOutputs(scope, denseFeatures));
+    opBuilder.addInput(exampleWeights.asOutput(scope));
+    opBuilder.addInput(exampleLabels.asOutput(scope));
+    opBuilder.addInputList(Operands.asOutputs(scope, sparseIndices));
+    opBuilder.addInputList(Operands.asOutputs(scope, sparseWeights));
+    opBuilder.addInputList(Operands.asOutputs(scope, denseWeights));
+    opBuilder.addInput(exampleStateData.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("loss_type", lossType);
     opBuilder.setAttr("l1", l1);
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 d531030e063..74ccb223c44 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
@@ -46,7 +46,7 @@ public final class SdcaShrinkL1 extends RawOp {
   @Endpoint(describeByClass = true)
   public static SdcaShrinkL1 create(Scope scope, Iterable<Operand<TFloat32>> weights, Float l1, Float l2) {
     OperationBuilder opBuilder = scope.env().opBuilder("SdcaShrinkL1", scope.makeOpName("SdcaShrinkL1"));
-    opBuilder.addInputList(Operands.asOutputs(weights));
+    opBuilder.addInputList(Operands.asOutputs(scope, weights));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("l1", l1);
     opBuilder.setAttr("l2", l2);
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 d35d1985174..5da4d4ddecc 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * var: Should be from a Variable().
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyAdadelta<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyAdadelta<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdadelta}
@@ -72,16 +72,16 @@ private Options() {
    * @return a new instance of SparseApplyAdadelta
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyAdadelta<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> accumUpdate, Operand<T> lr, Operand<T> rho, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyAdadelta", scope.makeOpName("SparseApplyAdadelta"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(accumUpdate.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(accumUpdate.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -109,7 +109,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 2d08b2cde13..52ec668070e 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
@@ -37,7 +37,7 @@
  * 
  * @param <T> data type for {@code out()} output
  */
-public final class SparseApplyAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdagrad}
@@ -83,14 +83,14 @@ private Options() {
    * @return a new instance of SparseApplyAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyAdagradV2", scope.makeOpName("SparseApplyAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -129,7 +129,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 5a5fcf03093..5ff9d0177eb 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,13 +21,13 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
@@ -35,7 +35,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyAdagradDa<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyAdagradDa<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyAdagradDa}
@@ -74,17 +74,17 @@ private Options() {
    * @return a new instance of SparseApplyAdagradDa
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyAdagradDa<T> create(Scope scope, Operand<T> var, Operand<T> gradientAccumulator, Operand<T> gradientSquaredAccumulator, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<TInt64> globalStep, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyAdagradDA", scope.makeOpName("SparseApplyAdagradDa"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(gradientAccumulator.asOutput());
-    opBuilder.addInput(gradientSquaredAccumulator.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(globalStep.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(gradientAccumulator.asOutput(scope));
+    opBuilder.addInput(gradientSquaredAccumulator.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(globalStep.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -112,7 +112,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 19513a28693..41ea69451a3 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the centered RMSProp algorithm.
@@ -51,7 +51,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyCenteredRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyCenteredRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyCenteredRmsProp}
@@ -92,18 +92,18 @@ private Options() {
    * @return a new instance of SparseApplyCenteredRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyCenteredRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> mg, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyCenteredRMSProp", scope.makeOpName("SparseApplyCenteredRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(mg.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(mg.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -132,7 +132,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 fe6e7b6b248..b6f002a4941 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' according to the Ftrl-proximal scheme.
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyFtrl<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyFtrl<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyFtrl}
@@ -84,18 +84,18 @@ private Options() {
    * @return a new instance of SparseApplyFtrl
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyFtrl<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> linear, Operand<T> grad, Operand<U> indices, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> l2Shrinkage, Operand<T> lrPower, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyFtrlV2", scope.makeOpName("SparseApplyFtrl"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(linear.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(l2Shrinkage.asOutput());
-    opBuilder.addInput(lrPower.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(linear.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(l2Shrinkage.asOutput(scope));
+    opBuilder.addInput(lrPower.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -124,7 +124,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 fb6a4fd1eb5..4f23b8510b1 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update relevant entries in '*var' and '*accum' according to the momentum scheme.
@@ -41,7 +41,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyMomentum<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyMomentum<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyMomentum}
@@ -89,14 +89,14 @@ private Options() {
    * @return a new instance of SparseApplyMomentum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyMomentum<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> grad, Operand<U> indices, Operand<T> momentum, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyMomentum", scope.makeOpName("SparseApplyMomentum"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
-    opBuilder.addInput(momentum.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -137,7 +137,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 7d73ebe6ee1..d199b33477f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
@@ -40,7 +40,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyProximalAdagrad<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyProximalAdagrad<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyProximalAdagrad}
@@ -77,15 +77,15 @@ private Options() {
    * @return a new instance of SparseApplyProximalAdagrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyProximalAdagrad<T> create(Scope scope, Operand<T> var, Operand<T> accum, Operand<T> lr, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyProximalAdagrad", scope.makeOpName("SparseApplyProximalAdagrad"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(accum.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(accum.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -113,7 +113,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 41b24e50b88..8d44f8d27e2 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sparse update '*var' as FOBOS algorithm with fixed learning rate.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyProximalGradientDescent<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyProximalGradientDescent<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyProximalGradientDescent}
@@ -74,14 +74,14 @@ private Options() {
    * @return a new instance of SparseApplyProximalGradientDescent
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyProximalGradientDescent<T> create(Scope scope, Operand<T> var, Operand<T> alpha, Operand<T> l1, Operand<T> l2, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyProximalGradientDescent", scope.makeOpName("SparseApplyProximalGradientDescent"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(alpha.asOutput());
-    opBuilder.addInput(l1.asOutput());
-    opBuilder.addInput(l2.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(alpha.asOutput(scope));
+    opBuilder.addInput(l1.asOutput(scope));
+    opBuilder.addInput(l2.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -109,7 +109,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 1481b9cf04c..ab1b9f9d388 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Update '*var' according to the RMSProp algorithm.
@@ -45,7 +45,7 @@
  * @param <T> data type for {@code out()} output
  */
 @Operator(group = "train")
-public final class SparseApplyRmsProp<T extends Tensor> extends RawOp implements Operand<T> {
+public final class SparseApplyRmsProp<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Optional attributes for {@link org.tensorflow.op.train.SparseApplyRmsProp}
@@ -85,17 +85,17 @@ private Options() {
    * @return a new instance of SparseApplyRmsProp
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> SparseApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
+  public static <T extends TType, U extends TNumber> SparseApplyRmsProp<T> create(Scope scope, Operand<T> var, Operand<T> ms, Operand<T> mom, Operand<T> lr, Operand<T> rho, Operand<T> momentum, Operand<T> epsilon, Operand<T> grad, Operand<U> indices, Options... options) {
     OperationBuilder opBuilder = scope.env().opBuilder("SparseApplyRMSProp", scope.makeOpName("SparseApplyRmsProp"));
-    opBuilder.addInput(var.asOutput());
-    opBuilder.addInput(ms.asOutput());
-    opBuilder.addInput(mom.asOutput());
-    opBuilder.addInput(lr.asOutput());
-    opBuilder.addInput(rho.asOutput());
-    opBuilder.addInput(momentum.asOutput());
-    opBuilder.addInput(epsilon.asOutput());
-    opBuilder.addInput(grad.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(var.asOutput(scope));
+    opBuilder.addInput(ms.asOutput(scope));
+    opBuilder.addInput(mom.asOutput(scope));
+    opBuilder.addInput(lr.asOutput(scope));
+    opBuilder.addInput(rho.asOutput(scope));
+    opBuilder.addInput(momentum.asOutput(scope));
+    opBuilder.addInput(epsilon.asOutput(scope));
+    opBuilder.addInput(grad.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     if (options != null) {
       for (Options opts : options) {
@@ -124,7 +124,7 @@ public Output<T> out() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return out;
   }
   
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 01430a5a737..891e3d2b48f 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,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /**
  * Returns the gradient of `Tile`.
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "train")
-public final class TileGrad<T extends Tensor> extends RawOp 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.
@@ -49,10 +49,10 @@ public final class TileGrad<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of TileGrad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> TileGrad<T> create(Scope scope, Operand<T> input, Operand<TInt32> multiples) {
+  public static <T extends TType> TileGrad<T> create(Scope scope, Operand<T> input, Operand<TInt32> multiples) {
     OperationBuilder opBuilder = scope.env().opBuilder("TileGrad", scope.makeOpName("TileGrad"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(multiples.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(multiples.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new TileGrad<T>(opBuilder.build());
   }
@@ -64,7 +64,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java
index bd9a7c2f576..40e3fd243c8 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/BroadcastHelper.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Helper operator for performing XLA-style broadcasts
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code lhsOutput()} output
  */
 @Operator(group = "xla")
-public final class BroadcastHelper<T extends Tensor> extends RawOp {
+public final class BroadcastHelper<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new BroadcastHelper operation.
@@ -50,11 +50,11 @@ public final class BroadcastHelper<T extends Tensor> extends RawOp {
    * @return a new instance of BroadcastHelper
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> BroadcastHelper<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> broadcastDims) {
+  public static <T extends TType, U extends TNumber> BroadcastHelper<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> broadcastDims) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaBroadcastHelper", scope.makeOpName("BroadcastHelper"));
-    opBuilder.addInput(lhs.asOutput());
-    opBuilder.addInput(rhs.asOutput());
-    opBuilder.addInput(broadcastDims.asOutput());
+    opBuilder.addInput(lhs.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
+    opBuilder.addInput(broadcastDims.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new BroadcastHelper<T>(opBuilder.build());
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java
index 7eb6a9ede78..f77b6799a1b 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ClusterOutput.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Operator that connects the output of an XLA computation to other consumer graph nodes.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code outputs()} output
  */
 @Operator(group = "xla")
-public final class ClusterOutput<T extends Tensor> extends RawOp implements Operand<T> {
+public final class ClusterOutput<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new ClusterOutput operation.
@@ -43,9 +43,9 @@ public final class ClusterOutput<T extends Tensor> extends RawOp implements Oper
    * @return a new instance of ClusterOutput
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> ClusterOutput<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> ClusterOutput<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaClusterOutput", scope.makeOpName("ClusterOutput"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new ClusterOutput<T>(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<T> outputs() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return outputs;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java
index 0f478d65e81..49fa285d435 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Conv.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA ConvGeneralDilated operator, documented at
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Conv<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Conv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Conv operation.
@@ -55,15 +55,15 @@ public final class Conv<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Conv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Conv<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> windowStrides, Operand<U> padding, Operand<U> lhsDilation, Operand<U> rhsDilation, Operand<U> featureGroupCount, String dimensionNumbers, String precisionConfig) {
+  public static <T extends TType, U extends TNumber> Conv<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, Operand<U> windowStrides, Operand<U> padding, Operand<U> lhsDilation, Operand<U> rhsDilation, Operand<U> featureGroupCount, String dimensionNumbers, String precisionConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaConv", scope.makeOpName("Conv"));
-    opBuilder.addInput(lhs.asOutput());
-    opBuilder.addInput(rhs.asOutput());
-    opBuilder.addInput(windowStrides.asOutput());
-    opBuilder.addInput(padding.asOutput());
-    opBuilder.addInput(lhsDilation.asOutput());
-    opBuilder.addInput(rhsDilation.asOutput());
-    opBuilder.addInput(featureGroupCount.asOutput());
+    opBuilder.addInput(lhs.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
+    opBuilder.addInput(windowStrides.asOutput(scope));
+    opBuilder.addInput(padding.asOutput(scope));
+    opBuilder.addInput(lhsDilation.asOutput(scope));
+    opBuilder.addInput(rhsDilation.asOutput(scope));
+    opBuilder.addInput(featureGroupCount.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dimension_numbers", dimensionNumbers);
     opBuilder.setAttr("precision_config", precisionConfig);
@@ -77,7 +77,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dequantize.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dequantize.java
index 751e47f4d5b..3b9762c2326 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dequantize.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dequantize.java
@@ -50,7 +50,7 @@ public final class Dequantize extends RawOp implements Operand<TBfloat16> {
   @Endpoint(describeByClass = true)
   public static Dequantize create(Scope scope, Operand<?> input, Float minRange, Float maxRange, String mode, Boolean transposeOutput) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaDequantize", scope.makeOpName("Dequantize"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("min_range", minRange);
     opBuilder.setAttr("max_range", maxRange);
@@ -69,7 +69,7 @@ public Output<TBfloat16> output() {
   }
   
   @Override
-  public Output<TBfloat16> asOutput() {
+  public Output<TBfloat16> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java
index c825c070a29..042084ec588 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Dot.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA DotGeneral operator, documented at
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Dot<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Dot<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Dot operation.
@@ -49,10 +49,10 @@ public final class Dot<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Dot
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Dot<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, String dimensionNumbers, String precisionConfig) {
+  public static <T extends TType> Dot<T> create(Scope scope, Operand<T> lhs, Operand<T> rhs, String dimensionNumbers, String precisionConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaDot", scope.makeOpName("Dot"));
-    opBuilder.addInput(lhs.asOutput());
-    opBuilder.addInput(rhs.asOutput());
+    opBuilder.addInput(lhs.asOutput(scope));
+    opBuilder.addInput(rhs.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dimension_numbers", dimensionNumbers);
     opBuilder.setAttr("precision_config", precisionConfig);
@@ -66,7 +66,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java
index 0f51e78708d..18f5d0ad2cc 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicSlice.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA DynamicSlice operator, documented at
@@ -43,7 +43,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class DynamicSlice<T extends Tensor> extends RawOp implements Operand<T> {
+public final class DynamicSlice<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DynamicSlice operation.
@@ -58,11 +58,11 @@ public final class DynamicSlice<T extends Tensor> extends RawOp implements Opera
    * @return a new instance of DynamicSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> DynamicSlice<T> create(Scope scope, Operand<T> input, Operand<U> startIndices, Operand<U> sizeIndices) {
+  public static <T extends TType, U extends TNumber> DynamicSlice<T> create(Scope scope, Operand<T> input, Operand<U> startIndices, Operand<U> sizeIndices) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaDynamicSlice", scope.makeOpName("DynamicSlice"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(startIndices.asOutput());
-    opBuilder.addInput(sizeIndices.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(startIndices.asOutput(scope));
+    opBuilder.addInput(sizeIndices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DynamicSlice<T>(opBuilder.build());
   }
@@ -74,7 +74,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java
index 7784b7eccb3..013bd8896a6 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/DynamicUpdateSlice.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA DynamicUpdateSlice operator, documented at
@@ -44,7 +44,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class DynamicUpdateSlice<T extends Tensor> extends RawOp implements Operand<T> {
+public final class DynamicUpdateSlice<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new DynamicUpdateSlice operation.
@@ -57,11 +57,11 @@ public final class DynamicUpdateSlice<T extends Tensor> extends RawOp implements
    * @return a new instance of DynamicUpdateSlice
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> DynamicUpdateSlice<T> create(Scope scope, Operand<T> input, Operand<T> update, Operand<U> indices) {
+  public static <T extends TType, U extends TNumber> DynamicUpdateSlice<T> create(Scope scope, Operand<T> input, Operand<T> update, Operand<U> indices) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaDynamicUpdateSlice", scope.makeOpName("DynamicUpdateSlice"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(update.asOutput());
-    opBuilder.addInput(indices.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(update.asOutput(scope));
+    opBuilder.addInput(indices.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new DynamicUpdateSlice<T>(opBuilder.build());
   }
@@ -74,7 +74,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java
index b94c88fea8a..2e8217cf153 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Einsum.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * An op which supports basic einsum op with 2 inputs and 1 output.
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code product()} output
  */
 @Operator(group = "xla")
-public final class Einsum<T extends Tensor> extends RawOp 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.
@@ -48,10 +48,10 @@ public final class Einsum<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Einsum
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Einsum<T> create(Scope scope, Operand<T> a, Operand<T> b, String equation) {
+  public static <T extends TType> Einsum<T> create(Scope scope, Operand<T> a, Operand<T> b, String equation) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaEinsum", scope.makeOpName("Einsum"));
-    opBuilder.addInput(a.asOutput());
-    opBuilder.addInput(b.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
+    opBuilder.addInput(b.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("equation", equation);
     return new Einsum<T>(opBuilder.build());
@@ -64,7 +64,7 @@ public Output<T> product() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return product;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java
index 4a2fcc9d6a8..c34ba00dd16 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Gather.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Gather operator documented at
@@ -36,7 +36,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Gather<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Gather<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Gather operation.
@@ -50,11 +50,11 @@ public final class Gather<T extends Tensor> extends RawOp implements Operand<T>
    * @return a new instance of Gather
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Gather<T> create(Scope scope, Operand<T> operand, Operand<U> startIndices, Operand<U> sliceSizes, String dimensionNumbers, Boolean indicesAreSorted) {
+  public static <T extends TType, U extends TNumber> Gather<T> create(Scope scope, Operand<T> operand, Operand<U> startIndices, Operand<U> sliceSizes, String dimensionNumbers, Boolean indicesAreSorted) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaGather", scope.makeOpName("Gather"));
-    opBuilder.addInput(operand.asOutput());
-    opBuilder.addInput(startIndices.asOutput());
-    opBuilder.addInput(sliceSizes.asOutput());
+    opBuilder.addInput(operand.asOutput(scope));
+    opBuilder.addInput(startIndices.asOutput(scope));
+    opBuilder.addInput(sliceSizes.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dimension_numbers", dimensionNumbers);
     opBuilder.setAttr("indices_are_sorted", indicesAreSorted);
@@ -68,7 +68,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java
index 731e2d4c73a..6787693b731 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/KeyValueSort.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Sort operator, documented at
@@ -40,7 +40,7 @@
  * @param <U> data type for {@code sortedValues()} output
  */
 @Operator(group = "xla")
-public final class KeyValueSort<T extends Tensor & TNumber, U extends Tensor> extends RawOp {
+public final class KeyValueSort<T extends TNumber, U extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new KeyValueSort operation.
@@ -51,10 +51,10 @@ public final class KeyValueSort<T extends Tensor & TNumber, U extends Tensor> ex
    * @return a new instance of KeyValueSort
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor & TNumber, U extends Tensor> KeyValueSort<T, U> create(Scope scope, Operand<T> keys, Operand<U> values) {
+  public static <T extends TNumber, U extends TType> KeyValueSort<T, U> create(Scope scope, Operand<T> keys, Operand<U> values) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaKeyValueSort", scope.makeOpName("KeyValueSort"));
-    opBuilder.addInput(keys.asOutput());
-    opBuilder.addInput(values.asOutput());
+    opBuilder.addInput(keys.asOutput(scope));
+    opBuilder.addInput(values.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new KeyValueSort<T, U>(opBuilder.build());
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java
index 17dbca55b10..ac5eb5b1efe 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Pad.java
@@ -21,12 +21,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Pad operator, documented at
@@ -37,7 +37,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Pad<T extends Tensor> extends RawOp 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.
@@ -51,13 +51,13 @@ public final class Pad<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Pad
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor, U extends Tensor & TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<T> paddingValue, Operand<U> paddingLow, Operand<U> paddingHigh, Operand<U> paddingInterior) {
+  public static <T extends TType, U extends TNumber> Pad<T> create(Scope scope, Operand<T> input, Operand<T> paddingValue, Operand<U> paddingLow, Operand<U> paddingHigh, Operand<U> paddingInterior) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaPad", scope.makeOpName("Pad"));
-    opBuilder.addInput(input.asOutput());
-    opBuilder.addInput(paddingValue.asOutput());
-    opBuilder.addInput(paddingLow.asOutput());
-    opBuilder.addInput(paddingHigh.asOutput());
-    opBuilder.addInput(paddingInterior.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
+    opBuilder.addInput(paddingValue.asOutput(scope));
+    opBuilder.addInput(paddingLow.asOutput(scope));
+    opBuilder.addInput(paddingHigh.asOutput(scope));
+    opBuilder.addInput(paddingInterior.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Pad<T>(opBuilder.build());
   }
@@ -70,7 +70,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java
index 8a439f56dcc..d143de62040 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Recv.java
@@ -22,12 +22,12 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Receives the named tensor from another XLA computation. Wraps the XLA Recv
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code tensor()} output
  */
 @Operator(group = "xla")
-public final class Recv<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Recv<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Recv operation.
@@ -50,7 +50,7 @@ public final class Recv<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Recv
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Recv<T> create(Scope scope, DataType<T> dtype, String tensorName, Shape shape) {
+  public static <T extends TType> Recv<T> create(Scope scope, DataType<T> dtype, String tensorName, Shape shape) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaRecv", scope.makeOpName("Recv"));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("dtype", dtype);
@@ -67,7 +67,7 @@ public Output<T> tensor() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return tensor;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ReplicaId.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ReplicaId.java
index a27b87f6c1a..abdcd36f60c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ReplicaId.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/ReplicaId.java
@@ -53,7 +53,7 @@ public Output<TInt32> id() {
   }
   
   @Override
-  public Output<TInt32> asOutput() {
+  public Output<TInt32> asOutput(Scope scope) {
     return id;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java
index 5f060e363b0..7a57ecdaf08 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/SelfAdjointEig.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of a batch of self-adjoint matrices
@@ -39,7 +39,7 @@
  * @param <T> data type for {@code w()} output
  */
 @Operator(group = "xla")
-public final class SelfAdjointEig<T extends Tensor> extends RawOp {
+public final class SelfAdjointEig<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new SelfAdjointEig operation.
@@ -56,9 +56,9 @@ public final class SelfAdjointEig<T extends Tensor> extends RawOp {
    * @return a new instance of SelfAdjointEig
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> SelfAdjointEig<T> create(Scope scope, Operand<T> a, Boolean lower, Long maxIter, Float epsilon) {
+  public static <T extends TType> SelfAdjointEig<T> create(Scope scope, Operand<T> a, Boolean lower, Long maxIter, Float epsilon) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSelfAdjointEig", scope.makeOpName("SelfAdjointEig"));
-    opBuilder.addInput(a.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("lower", lower);
     opBuilder.setAttr("max_iter", maxIter);
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java
index 64effb04c09..903983ba457 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Send.java
@@ -20,11 +20,11 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Sends the named tensor to another XLA computation. Wraps the XLA Send operator
@@ -44,9 +44,9 @@ public final class Send extends RawOp {
    * @return a new instance of Send
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Send create(Scope scope, Operand<T> tensor, String tensorName) {
+  public static <T extends TType> Send create(Scope scope, Operand<T> tensor, String tensorName) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSend", scope.makeOpName("Send"));
-    opBuilder.addInput(tensor.asOutput());
+    opBuilder.addInput(tensor.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("tensor_name", tensorName);
     return new Send(opBuilder.build());
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java
index a88479fab0d..71a82b50097 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sharding.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * An op which shards the input based on the given sharding attribute.
@@ -33,7 +33,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Sharding<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Sharding<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sharding operation.
@@ -43,9 +43,9 @@ public final class Sharding<T extends Tensor> extends RawOp implements Operand<T
    * @return a new instance of Sharding
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sharding<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Sharding<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSharding", scope.makeOpName("Sharding"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sharding<T>(opBuilder.build());
   }
@@ -57,7 +57,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java
index b3bf7be404e..a72c4625005 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Sort.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Wraps the XLA Sort operator, documented at
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code output()} output
  */
 @Operator(group = "xla")
-public final class Sort<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Sort<T extends TType> extends RawOp implements Operand<T> {
   
   /**
    * Factory method to create a class wrapping a new Sort operation.
@@ -48,9 +48,9 @@ public final class Sort<T extends Tensor> extends RawOp implements Operand<T> {
    * @return a new instance of Sort
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Sort<T> create(Scope scope, Operand<T> input) {
+  public static <T extends TType> Sort<T> create(Scope scope, Operand<T> input) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSort", scope.makeOpName("Sort"));
-    opBuilder.addInput(input.asOutput());
+    opBuilder.addInput(input.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     return new Sort<T>(opBuilder.build());
   }
@@ -63,7 +63,7 @@ public Output<T> output() {
   }
   
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java
index ff212b541ef..6d5cb0cab1c 100644
--- a/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java
+++ b/tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/xla/Svd.java
@@ -21,11 +21,11 @@
 import org.tensorflow.Operation;
 import org.tensorflow.OperationBuilder;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.RawOp;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Computes the eigen decomposition of a batch of self-adjoint matrices
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code s()} output
  */
 @Operator(group = "xla")
-public final class Svd<T extends Tensor> extends RawOp {
+public final class Svd<T extends TType> extends RawOp {
   
   /**
    * Factory method to create a class wrapping a new Svd operation.
@@ -54,9 +54,9 @@ public final class Svd<T extends Tensor> extends RawOp {
    * @return a new instance of Svd
    */
   @Endpoint(describeByClass = true)
-  public static <T extends Tensor> Svd<T> create(Scope scope, Operand<T> a, Long maxIter, Float epsilon, String precisionConfig) {
+  public static <T extends TType> Svd<T> create(Scope scope, Operand<T> a, Long maxIter, Float epsilon, String precisionConfig) {
     OperationBuilder opBuilder = scope.env().opBuilder("XlaSvd", scope.makeOpName("Svd"));
-    opBuilder.addInput(a.asOutput());
+    opBuilder.addInput(a.asOutput(scope));
     opBuilder = scope.applyControlDependencies(opBuilder);
     opBuilder.setAttr("max_iter", maxIter);
     opBuilder.setAttr("epsilon", epsilon);
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java
index 71a9bc45bcf..96da6bc5ff4 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractOperation.java
@@ -17,6 +17,7 @@
 
 import org.bytedeco.javacpp.Pointer;
 import org.tensorflow.ndarray.Shape;
+import org.tensorflow.types.family.TType;
 
 /**
  * Base class for {@link Operation} implementations.
@@ -36,7 +37,7 @@ public Output<?>[] outputList(int idx, int length) {
   }
 
   @Override
-  public <T extends Tensor> Output<T> output(int idx) {
+  public <T extends TType> Output<T> output(int idx) {
     return new Output<>(this, idx);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractTensor.java
new file mode 100644
index 00000000000..71fd952bd6a
--- /dev/null
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/AbstractTensor.java
@@ -0,0 +1,105 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+package org.tensorflow;
+
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_Dim;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_NumDims;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorByteSize;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorType;
+
+import java.util.function.Consumer;
+import org.bytedeco.javacpp.PointerScope;
+import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.types.family.TType;
+
+/**
+ * A basic implementation of a dense tensor.
+ *
+ * <p>Dense tensors are stored as a continuous segment of native memory, mapped in a n-dimensional
+ * space, normally by delegating all I/O operations to an {@link NdArray} instance.
+ *
+ * <p>Usage of this class is meant to be kept internal.
+ */
+public abstract class AbstractDenseTensor<T> implements Tensor<T> {
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public <U extends TType> U expect(DataType<U> dt) {
+    if (!dt.equals(this.dtype)) {
+      throw new IllegalArgumentException(
+          "Cannot cast from tensor of " + dtype + " to tensor of " + dt);
+    }
+    return (U)this;
+  }
+
+  @Override
+  public void close() {
+    nativeHandle().close();
+  }
+
+  @Override
+  public DataType<?> dataType() {
+    return dtype;
+  }
+
+  @Override
+  public long numBytes() {
+    return TF_TensorByteSize(nativeHandle());
+  }
+
+  @Override
+  public ByteDataBuffer rawData() {
+    return TensorBuffers.toBytes(nativeHandle(), true);
+  }
+
+  @Override
+  public String toString() {
+    return String.format("%s tensor with shape %s", dtype.toString(), shape());
+  }
+
+  protected AbstractDenseTensor(TF_Tensor nativeHandle, DataType<?> dtype) {
+    this.nativeHandle = nativeHandle;
+    this.dtype = dtype;
+    nativeHandle.retainReference();
+  }
+
+  /**
+   * @return native handle to this tensor
+   * @throws IllegalStateException if tensor has been closed
+   */
+  protected TF_Tensor nativeHandle() {
+    return requireHandle(nativeHandle);
+  }
+
+  void attachTo(EagerSession session) {
+    session.attach(nativeHandle());
+    nativeHandle.releaseReference();
+  }
+
+  protected static TF_Tensor requireHandle(TF_Tensor handle) {
+    if (handle == null || handle.isNull()) {
+      throw new IllegalStateException("close() was called on the Tensor");
+    }
+    return handle;
+  }
+
+  private final TF_Tensor nativeHandle;
+  private final DataType<?> dtype;
+}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
index 974a04f3333..70edafa391a 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/DataType.java
@@ -17,9 +17,10 @@
 
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.Shape;
+import org.tensorflow.types.family.TType;
 
 /** Represents a type of elements in a {@link Tensor} */
-public final class DataType<T extends Tensor> {
+public final class DataType<T extends TType> {
 
   @FunctionalInterface
   public interface TensorInstantiator<T> {
@@ -42,7 +43,7 @@ public interface TensorInstantiator<T> {
    * @param byteSize size of an element of this type, in bytes, -1 if unknown
    * @param tensorMapper method for instantiating tensor from a native reference
    */
-  public static <T extends Tensor> DataType<T> create(String name, int value, int byteSize, TensorInstantiator<T> instantiator) {
+  public static <T extends TType> DataType<T> create(String name, int value, int byteSize, TensorInstantiator<T> instantiator) {
     return new DataType<>(name, value, byteSize, instantiator);
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java
index 690d5d1a4cb..cc0d93d6bac 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperation.java
@@ -135,7 +135,7 @@ private Tensor<?> resolveTensor(int outputIndex) {
     // instead.
     Tensor<?> tensor = resolveTensorHandle(getUnsafeNativeHandle(outputIndex), session);
     if (!outputTensors.compareAndSet(outputIndex, null, tensor)) {
-      session.detach(tensor.nativeHandle());
+      session.detach(((AbstractTensor)tensor).nativeHandle());
       tensor = outputTensors.get(outputIndex);
     }
     return tensor;
@@ -160,14 +160,10 @@ private static Tensor<?> resolveTensorHandle(TFE_TensorHandle handle, EagerSessi
     requireTensorHandle(handle);
     try (PointerScope scope = new PointerScope()) {
       TF_Status status = TF_Status.newStatus();
-      TF_Tensor tensor = TFE_TensorHandleResolve(handle, status).withDeallocator();
+      TF_Tensor nativeTensor = TFE_TensorHandleResolve(handle, status).withDeallocator();
       status.throwExceptionIfNotOK();
-      Tensor<?> t = Tensors.fromHandle(tensor);
-      session.attach(t.nativeHandle());
-      // Now that the tensor life is attached to the eager session scope, closing it will
-      // implicitly detach it from its previous internal scope
-      // FIXME TENSOR REFACT : is that right and ok?
-      t.close();
+      Tensor<?> t = Tensors.fromHandle(nativeTensor);
+      ((AbstractTensor)t).attachTo(session);
       return t;
     }
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperationBuilder.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperationBuilder.java
index f14795df55a..8bebb554e57 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperationBuilder.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/EagerOperationBuilder.java
@@ -176,7 +176,7 @@ public EagerOperationBuilder setAttr(String name, DataType<?>[] values) {
 
   @Override
   public EagerOperationBuilder setAttr(String name, Tensor<?> value) {
-    setAttrTensor(opHandle, name, value.nativeHandle());
+    setAttrTensor(opHandle, name, ((AbstractTensor)value).nativeHandle());
     return this;
   }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/GraphOperationBuilder.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/GraphOperationBuilder.java
index 2ef5c9010a1..e57c997b4b0 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/GraphOperationBuilder.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/GraphOperationBuilder.java
@@ -250,7 +250,7 @@ public GraphOperationBuilder setAttr(String name, DataType[] value) {
   public GraphOperationBuilder setAttr(String name, Tensor<?> value) {
     Graph.Reference r = graph.ref();
     try {
-      setAttrTensor(unsafeNativeHandle, name, value.nativeHandle());
+      setAttrTensor(unsafeNativeHandle, name, ((AbstractTensor)value).nativeHandle());
     } finally {
       r.close();
     }
@@ -262,7 +262,7 @@ public GraphOperationBuilder setAttr(String name, Tensor<?>[] value) {
     TF_Tensor[] handles = new TF_Tensor[value.length];
     int idx = 0;
     for (Tensor<?> t : value) {
-      handles[idx++] = t.nativeHandle();
+      handles[idx++] = ((AbstractTensor)t).nativeHandle();
     }
     Graph.Reference r = graph.ref();
     try {
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 78228d1a5ec..d80ce85dab2 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
@@ -16,6 +16,7 @@
 package org.tensorflow;
 
 import org.tensorflow.op.Op;
+import org.tensorflow.op.Scope;
 import org.tensorflow.types.family.TType;
 
 /**
@@ -39,7 +40,7 @@
  * tf.concat(split, tf.constant(0));
  * }</pre>
  */
-public interface Operand<T extends Tensor> extends Op {
+public interface Operand<T extends TType> extends Op {
 
   /**
    * Returns the symbolic handle of the tensor.
@@ -47,9 +48,26 @@ public interface Operand<T extends Tensor> extends Op {
    * <p>Inputs to TensorFlow operations are outputs of another TensorFlow operation. This method is
    * used to obtain a symbolic handle that represents the computation of the input.
    *
+   * <p>If a valid non-null value is provided as the {@code scope} of this operand, the implementor
+   * can program additional computations before returning its output. This might be required if,
+   * for instance, the implementor has not yet been added as a node to the graph.</p>
+   *
+   * @param scope if non-null, scope that can be used by the operand to produce a new output
    * @see OperationBuilder#addInput(Output)
    */
-  Output<T> asOutput();
+  Output<T> asOutput(Scope scope);
+
+  /**
+   * Returns the symbolic handle of the tensor.
+   *
+   * <p>Inputs to TensorFlow operations are outputs of another TensorFlow operation. This method is
+   * used to obtain a symbolic handle that represents the computation of the input.
+   *
+   * @see OperationBuilder#addInput(Output)
+   */
+  default Output<T> asOutput() {
+    return asOutput(null);
+  }
 
   /**
    * Returns this operand as a tensor.
@@ -65,17 +83,16 @@ default T asTensor() {
   }
 
   /**
-   * Returns the data of this operand.
+   * Returns this operand as a tensor of the given type.
    *
    * <i>Only works when running in an eager execution</i>
-   * <p>This helper method is equivalent to {@code asTensor().data()}
+   * <p>This helper method is equivalent to {@code asOutput().tensor()}
    *
-   * @return the tensor data
+   * @return the tensor
    * @throws IllegalStateException if this is an operand of a graph
-   * @deprecated use {@link #asTensor()} instead
+   * @throws IllegalArgumentException if the {@code dataType} is incompatible with tensor type
    */
-  @Deprecated
-  default T data() {
-    return asTensor();
+  default <U extends TType> U asTensor(DataType<U> dataType) {
+    return (U)asOutput().tensor().expect(dataType);
   }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java
index dd7903e07a6..1cc175da161 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Operation.java
@@ -15,6 +15,8 @@
 
 package org.tensorflow;
 
+import org.tensorflow.types.family.TType;
+
 /**
  * Performs computation on Tensors.
  *
@@ -68,7 +70,7 @@ public interface Operation {
    * @param <T> The expected element type of the tensors produced by this output.
    * @param idx The index of the output among the outputs produced by this operation.
    */
-  <T extends Tensor> Output<T> output(int idx);
+  <T extends TType> Output<T> output(int idx);
 
   /**
    * Returns the size of the given inputs list of Tensors for this operation.
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 944ed507ee1..55979a5f6da 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
@@ -18,6 +18,8 @@
 import java.util.Objects;
 import org.bytedeco.javacpp.Pointer;
 import org.tensorflow.ndarray.Shape;
+import org.tensorflow.op.Scope;
+import org.tensorflow.types.family.TType;
 
 /**
  * A symbolic handle to a tensor produced by an {@link Operation}.
@@ -28,7 +30,7 @@
  * <p>By implementing the {@link Operand} interface, instances of this class also act as operands to
  * {@link org.tensorflow.op.Op Op} instances.
  */
-public final class Output<T extends Tensor> implements Operand<T> {
+public final class Output<T extends TType> implements Operand<T> {
 
   /** Returns the index into the outputs of the Operation. */
   public int index() {
@@ -55,7 +57,7 @@ public DataType<T> dataType() {
    *     {@code U}.
    */
   @SuppressWarnings("unchecked")
-  public <U extends Tensor> Output<U> expect(DataType<U> dt) {
+  public <U extends TType> Output<U> expect(DataType<U> dt) {
     if (!dt.equals(this.dataType())) {
       throw new IllegalArgumentException(
           "Cannot cast from output of " + this.dataType() + " to output of " + dt);
@@ -89,7 +91,7 @@ public Operation op() {
   }
 
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return this;
   }
 
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 91c4e6b2b7b..47a96c1c3f7 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
@@ -15,7 +15,16 @@
 
 package org.tensorflow;
 
+import static org.tensorflow.Graph.resolveOutputs;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_CloseSession;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_DeleteSession;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_NewSession;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_SessionRun;
+import static org.tensorflow.internal.c_api.global.tensorflow.TF_SetConfig;
+
 import com.google.protobuf.InvalidProtocolBufferException;
+import java.util.ArrayList;
+import java.util.List;
 import org.bytedeco.javacpp.BytePointer;
 import org.bytedeco.javacpp.Pointer;
 import org.bytedeco.javacpp.PointerPointer;
@@ -34,12 +43,6 @@
 import org.tensorflow.proto.framework.RunMetadata;
 import org.tensorflow.proto.framework.RunOptions;
 
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.tensorflow.Graph.resolveOutputs;
-import static org.tensorflow.internal.c_api.global.tensorflow.*;
-
 /**
  * Driver for {@link Graph} execution.
  *
@@ -309,7 +312,7 @@ private Run runHelper(boolean wantMetadata) {
       // validity of the Graph and graphRef ensures that.
       int idx = 0;
       for (Tensor<?> t : inputTensors) {
-        inputTensorHandles[idx++] = t.nativeHandle();
+        inputTensorHandles[idx++] = ((AbstractTensor)t).nativeHandle();
       }
       idx = 0;
       for (Output<?> o : inputs) {
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 c74492dd231..03860c44f05 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
@@ -15,12 +15,11 @@
 
 package org.tensorflow;
 
-import java.util.function.Consumer;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
-import org.tensorflow.internal.c_api.TF_Tensor;
+import org.checkerframework.checker.units.qual.C;
 import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.buffer.DataBuffer;
+import org.tensorflow.types.family.TType;
 
 /**
  * A statically typed multi-dimensional array whose elements are of a type described by T.
@@ -39,133 +38,6 @@
  */
 public interface Tensor<T> extends NdArray<T>, AutoCloseable {
 
-  /**
-   * Allocates a tensor of a given datatype and shape.
-   *
-   * <p>The amount of memory to allocate is derived from the datatype and the shape of the tensor.
-   * Memory is left uninitialized after this method returns, so it is the responsibility of the
-   * caller to initialize the tensor data before it is used, via the {@link #data()} accessor.
-   * For example:
-   *
-   * <pre>{@code
-   * FloatNdArray data = ...
-   * try (Tensor<TFloat32> t = Tensor.of(TFloat32.DTYPE, Shape.of(2, 2))) {
-   *   data.copyTo(t.data());
-   *   ...
-   * }
-   * }</pre>
-   *
-   * @param <T> the tensor element type
-   * @param dtype datatype of the tensor
-   * @param shape shape of the tensor
-   * @return an allocated but uninitialized tensor
-   * @throws IllegalStateException if tensor failed to be allocated
-   */
-  static <T extends Tensor> T of(DataType<T> dtype, Shape shape) {
-    return of(dtype, shape, shape.size() * dtype.byteSize());
-  }
-
-  /**
-   * Allocates a tensor of a given datatype, shape and size.
-   *
-   * <p>This method is identical to {@link #of(DataType, Shape)}, except that the final size of the
-   * tensor is explicitly set instead of computing it from the datatype and shape.
-   *
-   * <p>This could be useful for tensor types that stores data but also metadata in the tensor memory,
-   * like {@link org.tensorflow.types.TString TString}.
-   *
-   * @param <T> the tensor element type
-   * @param dtype datatype of the tensor
-   * @param shape shape of the tensor
-   * @param size size, in bytes, of the tensor
-   * @return an allocated but uninitialized tensor
-   * @see #of(DataType, Shape)
-   * @throws IllegalArgumentException if {@code size} is smaller than the minimum space required to
-   *                                  store the tensor data
-   * @throws IllegalStateException if tensor failed to be allocated
-   */
-  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, long size) {
-    return Tensors.allocate(dtype, shape, size);
-  }
-
-  /**
-   * Allocates and initialize a tensor of a given datatype and shape.
-   *
-   * <p>The amount of memory to allocate is derived from the datatype and the shape of the tensor.
-   * Tensor data is initialized by calling the {@code dataInitializer}, which receives in argument
-   * the value returned by {@link #data()} on the allocated tensor. For example:
-   *
-   * <pre>{@code
-   * FloatNdArray data = ...
-   * try (Tensor<TFloat32> t = Tensor.of(TFloat32.DTYPE, Shape.of(2, 2), data::copyTo)) {
-   *   ...
-   * }
-   * }</pre>
-   *
-   * <p>If {@code dataInitializer} fails and throws an exception, the allocated tensor will be
-   * automatically released before rethrowing the same exception.
-   *
-   * @param <T> the tensor element type
-   * @param dtype datatype of the tensor
-   * @param shape shape of the tensor
-   * @param dataInitializer method receiving accessor to the allocated tensor data for initialization
-   * @return an allocated and initialized tensor
-   * @throws IllegalStateException if tensor failed to be allocated
-   */
-  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, Consumer<T> dataInitializer) {
-    return of(dtype, shape, shape.size() * dtype.byteSize(), dataInitializer);
-  }
-
-  /**
-   * Allocates a tensor of a given datatype, shape and size.
-   *
-   * <p>This method is identical to {@link #of(DataType, Shape, Consumer)}, except that the final
-   * size for the tensor is explicitly set instead of being computed from the datatype and shape.
-   *
-   * <p>This could be useful for tensor types that stores data but also metadata in the tensor memory,
-   * such as {@link org.tensorflow.types.TString TString}.
-   *
-   * @param <T> the tensor element type
-   * @param dtype datatype of the tensor
-   * @param shape shape of the tensor
-   * @param size size, in bytes, of the tensor
-   * @param tensorInit method receiving accessor to the allocated tensor data for initialization
-   * @return an allocated and initialized tensor
-   * @see #of(DataType, Shape, long, Consumer)
-   * @throws IllegalArgumentException if {@code size} is smaller than the minimum space required to
-   *                                  store the tensor data
-   * @throws IllegalStateException if tensor failed to be allocated
-   */
-  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, long size, Consumer<T> tensorInit) {
-    T tensor = of(dtype, shape, size);
-    try {
-      tensorInit.accept(tensor);
-      return tensor;
-    } catch (Throwable t) {
-      tensor.close();
-      throw t;
-    }
-  }
-
-  /**
-   * Creates a Tensor of any type from the raw data provided by the given buffer.
-   *
-   * <p>Data must have been encoded into {@code data} as per the specification of the TensorFlow <a
-   * href="https://www.tensorflow.org/code/tensorflow/c/c_api.h">C API</a>.
-   *
-   * @param <T> the tensor element type
-   * @param dtype the tensor element data type
-   * @param shape the tensor shape.
-   * @param rawData a buffer containing the tensor raw data.
-   * @throws IllegalArgumentException if {@code rawData} is not large enough to contain the tensor data
-   * @throws IllegalStateException if tensor failed to be allocated with the given parameters
-   */
-  static <T extends Tensor> T of(DataType<T> dtype, Shape shape, ByteDataBuffer rawData) {
-    T tensor = of(dtype, shape, rawData.size());
-    rawData.copyTo(TensorBuffers.toBytes(tensor.nativeHandle()), rawData.size());
-    return tensor;
-  }
-
   /**
    * Returns this Tensor object with the type {@code Tensor<U>}. This method is useful when given a
    * value of type {@code Tensor<?>}.
@@ -174,14 +46,7 @@ static <T extends Tensor> T of(DataType<T> dtype, Shape shape, ByteDataBuffer ra
    * @throws IllegalArgumentException if the actual data type of this object does not match the type
    *     {@code U}.
    */
-  @SuppressWarnings("unchecked")
-  default <U extends Tensor> U expect(DataType<U> dt) {
-    if (!dt.equals(dataType())) {
-      throw new IllegalArgumentException(
-          "Cannot cast from tensor of " + dataType() + " to tensor of " + dt);
-    }
-    return (U)this;
-  }
+  <U extends TType> U expect(DataType<U> dt);
 
   /**
    * Release resources associated with the Tensor.
@@ -200,53 +65,6 @@ default <U extends Tensor> U expect(DataType<U> dt) {
   /** Returns the size, in bytes, of the tensor data. */
   long numBytes();
 
-  /**
-   * Returns the <a href="https://www.tensorflow.org/resources/dims_types.html#shape">shape</a> of
-   * the Tensor, i.e., the sizes of each dimension.
-   *
-   * @return shape of this tensor
-   */
-  Shape shape();
-
-  /**
-   * Returns the data of this tensor.
-   *
-   * <p>This method returns an accessor to the tensor data as an instance of {@code T}, which
-   * commonly maps this data to an {@link NdArray NdArray}. Input and
-   * output operations performed on the returned n-dimensional array are applied directly to the
-   * tensor native memory. For example:
-   *
-   * <pre>{@code
-   * Ops tf = Ops.create();
-   * try (Tensor<TFloat32> t = TFloat32.tensorOf(Shape.of(2, 2))) {
-   *   TFloat32 data = t.data();
-   *
-   *   StdArrays.copyTo(data, new float[][] {
-   *     {1.0f, 2.0f},
-   *     {3.0f, 4.0f}
-   *   });
-   *   assertEquals(NdArrays.vectorOf(3.0f, 4.0f), data.getFloat(1));
-   *
-   *   Constant<TFloat32> c = tf.constant(t);
-   *   assertEquals(4.0f, c.data().getFloat(1, 1));
-   * }
-   * }</pre>
-   *
-   * <p>Please refer to the documentation of the {@link NdArray NdArray}
-   * classes for more information on the various techniques to read or write data in an
-   * n-dimensional space using this data structure.
-   *
-   * @return the tensor data mapped to an n-dimensional space
-   * @throws IllegalStateException if the tensor has been closed
-   * @see NdArray
-   * @deprecated since tensor implements {@code NdArray}
-   */
-  @Deprecated
-  default Tensor<T> data() {
-    nativeHandle(); // make sure native handle is still valid
-    return this;
-  }
-
   /**
    * Returns the raw data of this tensor as a buffer of bytes.
    *
@@ -259,11 +77,20 @@ default Tensor<T> data() {
    */
   ByteDataBuffer rawData();
 
-  /**
-   * @return native handle to this tensor
-   * @throws IllegalStateException if tensor has been closed
-   */
-  TF_Tensor nativeHandle();
+  @Override
+  Tensor<T> set(NdArray<T> src, long... coordinates);
+
+  @Override
+  Tensor<T> setObject(T value, long... coordinates);
+
+  @Override
+  Tensor<T> copyTo(NdArray<T> dst);
+
+  @Override
+  Tensor<T> read(DataBuffer<T> dst);
+
+  @Override
+  Tensor<T> write(DataBuffer<T> src);
 }
 
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
index b04a0f297b9..3df1df81ddf 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/Tensors.java
@@ -4,14 +4,144 @@
 import static org.tensorflow.internal.c_api.global.tensorflow.TF_NumDims;
 import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorType;
 
+import java.util.function.Consumer;
 import org.bytedeco.javacpp.PointerScope;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.types.family.TType;
 
-final class Tensors {
+public final class Tensors {
 
-  static <T extends Tensor> T allocate(DataType<T> dataType, Shape shape, long size) {
+  /**
+   * Allocates a tensor of a given datatype and shape.
+   *
+   * <p>The amount of memory to allocate is derived from the datatype and the shape of the tensor.
+   * Memory is left uninitialized after this method returns, so it is the responsibility of the
+   * caller to initialize the tensor data before it is used, via the {@link #data()} accessor.
+   * For example:
+   *
+   * <pre>{@code
+   * FloatNdArray data = ...
+   * try (Tensor<TFloat32> t = Tensor.of(TFloat32.DTYPE, Shape.of(2, 2))) {
+   *   data.copyTo(t.data());
+   *   ...
+   * }
+   * }</pre>
+   *
+   * @param <T> the tensor element type
+   * @param dtype datatype of the tensor
+   * @param shape shape of the tensor
+   * @return an allocated but uninitialized tensor
+   * @throws IllegalStateException if tensor failed to be allocated
+   */
+  public static <T extends TType> T of(DataType<T> dtype, Shape shape) {
+    return of(dtype, shape, shape.size() * dtype.byteSize());
+  }
+
+  /**
+   * Allocates a tensor of a given datatype, shape and size.
+   *
+   * <p>This method is identical to {@link #of(DataType, Shape)}, except that the final size of the
+   * tensor is explicitly set instead of computing it from the datatype and shape.
+   *
+   * <p>This could be useful for tensor types that stores data but also metadata in the tensor memory,
+   * like {@link org.tensorflow.types.TString TString}.
+   *
+   * @param <T> the tensor element type
+   * @param dtype datatype of the tensor
+   * @param shape shape of the tensor
+   * @param size size, in bytes, of the tensor
+   * @return an allocated but uninitialized tensor
+   * @see #of(DataType, Shape)
+   * @throws IllegalArgumentException if {@code size} is smaller than the minimum space required to
+   *                                  store the tensor data
+   * @throws IllegalStateException if tensor failed to be allocated
+   */
+  public static <T extends TType> T of(DataType<T> dtype, Shape shape, long size) {
+    return Tensors.allocate(dtype, shape, size);
+  }
+
+  /**
+   * Allocates and initialize a tensor of a given datatype and shape.
+   *
+   * <p>The amount of memory to allocate is derived from the datatype and the shape of the tensor.
+   * Tensor data is initialized by calling the {@code dataInitializer}, which receives in argument
+   * the value returned by {@link #data()} on the allocated tensor. For example:
+   *
+   * <pre>{@code
+   * FloatNdArray data = ...
+   * try (Tensor<TFloat32> t = Tensor.of(TFloat32.DTYPE, Shape.of(2, 2), data::copyTo)) {
+   *   ...
+   * }
+   * }</pre>
+   *
+   * <p>If {@code dataInitializer} fails and throws an exception, the allocated tensor will be
+   * automatically released before rethrowing the same exception.
+   *
+   * @param <T> the tensor element type
+   * @param dtype datatype of the tensor
+   * @param shape shape of the tensor
+   * @param dataInitializer method receiving accessor to the allocated tensor data for initialization
+   * @return an allocated and initialized tensor
+   * @throws IllegalStateException if tensor failed to be allocated
+   */
+  public static <T extends TType> T of(DataType<T> dtype, Shape shape, Consumer<T> dataInitializer) {
+    return of(dtype, shape, shape.size() * dtype.byteSize(), dataInitializer);
+  }
+
+  /**
+   * Allocates a tensor of a given datatype, shape and size.
+   *
+   * <p>This method is identical to {@link #of(DataType, Shape, Consumer)}, except that the final
+   * size for the tensor is explicitly set instead of being computed from the datatype and shape.
+   *
+   * <p>This could be useful for tensor types that stores data but also metadata in the tensor memory,
+   * such as {@link org.tensorflow.types.TString TString}.
+   *
+   * @param <T> the tensor element type
+   * @param dtype datatype of the tensor
+   * @param shape shape of the tensor
+   * @param size size, in bytes, of the tensor
+   * @param tensorInit method receiving accessor to the allocated tensor data for initialization
+   * @return an allocated and initialized tensor
+   * @see #of(DataType, Shape, long, Consumer)
+   * @throws IllegalArgumentException if {@code size} is smaller than the minimum space required to
+   *                                  store the tensor data
+   * @throws IllegalStateException if tensor failed to be allocated
+   */
+  public static <T extends TType> T of(DataType<T> dtype, Shape shape, long size, Consumer<T> tensorInit) {
+    T tensor = of(dtype, shape, size);
+    try {
+      tensorInit.accept(tensor);
+      return tensor;
+    } catch (Throwable t) {
+      tensor.close();
+      throw t;
+    }
+  }
+
+  /**
+   * Creates a Tensor of any type from the raw data provided by the given buffer.
+   *
+   * <p>Data must have been encoded into {@code data} as per the specification of the TensorFlow <a
+   * href="https://www.tensorflow.org/code/tensorflow/c/c_api.h">C API</a>.
+   *
+   * @param <T> the tensor element type
+   * @param dtype the tensor element data type
+   * @param shape the tensor shape.
+   * @param rawData a buffer containing the tensor raw data.
+   * @throws IllegalArgumentException if {@code rawData} is not large enough to contain the tensor data
+   * @throws IllegalStateException if tensor failed to be allocated with the given parameters
+   */
+  public static <T extends TType> T of(DataType<T> dtype, Shape shape, ByteDataBuffer rawData) {
+    T tensor = of(dtype, shape, rawData.size());
+    rawData.copyTo(TensorBuffers.toBytes(((AbstractTensor)tensor).nativeHandle()), rawData.size());
+    return tensor;
+  }
+
+  static <T extends TType> T allocate(DataType<T> dataType, Shape shape, long size) {
     // Minimum requirements for datatypes of variable length cannot be verified in a relevant way so
     // we only validate them for fixed length datatypes
     if (!dataType.isVariableLength() && shape.size() * dataType.byteSize() > size) {
@@ -30,12 +160,9 @@ static <T extends Tensor> T allocate(DataType<T> dataType, Shape shape, long siz
    * <p>Takes ownership of the handle.
    */
   static Tensor<?> fromHandle(TF_Tensor handle) {
-    DataType<? extends Tensor> dataType = DataTypes.fromNativeCode(dtype(handle));
+    DataType<?> dataType = DataTypes.fromNativeCode(dtype(handle));
     Shape shape = Shape.of(shape(handle));
-    try (PointerScope scope = new PointerScope()) {
-      scope.attach(handle);
-      return dataType.instantiateTensor(handle, shape);
-    }
+    return dataType.instantiateTensor(handle, shape);
   }
 
   private static TF_Tensor requireHandle(TF_Tensor handle) {
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java
index 09318072a7f..9c7c059691d 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/BooleanTensorImpl.java
@@ -1,96 +1,143 @@
 package org.tensorflow.internal.tensor;
 
+import org.tensorflow.AbstractTensor;
 import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.BooleanNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArraySequence;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.impl.dense.BooleanDenseNdArray;
+import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
+import org.tensorflow.ndarray.index.Index;
 import org.tensorflow.tensor.BooleanTensor;
 
-public class BooleanTensorImpl extends BooleanDenseNdArray implements BooleanTensor {
+public class BooleanTensorImpl extends AbstractTensor<Boolean> implements BooleanTensor {
 
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
+  private final BooleanNdArray data;
+
+  public BooleanTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape,
+      BooleanDataBuffer buffer) {
+    super(nativeHandle, dataType);
+    data = NdArrays.wrap(shape, buffer);
   }
 
   @Override
-  public DataType<?> dataType() {
-    return rawTensor.dataType();
+  public boolean getBoolean(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getBoolean(coordinates);
   }
 
   @Override
-  public Shape shape() {
-    return rawTensor.shape();
+  public BooleanTensor setBoolean(boolean value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setBoolean(value, coordinates);
+    return this;
   }
 
   @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
+  public BooleanNdArray slice(Index... coordinates) {
+    requireHandle(nativeHandle);
+    return data.slice(coordinates);
   }
 
   @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
+  public BooleanTensor get(long... coordinates) {
+    requireHandle(nativeHandle);
+    data.get(coordinates);
+    return this;
   }
 
   @Override
-  public void close() {
-    rawTensor.close();
+  public BooleanTensor set(NdArray<Boolean> src, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.set(src, coordinates);
+    return this;
   }
 
   @Override
-  public String toString() {
-    return rawTensor.toString();
+  public Boolean getObject(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getObject(coordinates);
   }
 
   @Override
-  public BooleanTensor setBoolean(boolean value, long... coordinates) {
-    return (BooleanTensor)super.setBoolean(value, coordinates);
+  public BooleanTensor setObject(Boolean value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setObject(value, coordinates);
+    return this;
   }
 
   @Override
-  public BooleanTensor setObject(Boolean value, long... coordinates) {
-    return (BooleanTensor)super.setObject(value, coordinates);
+  public NdArraySequence<BooleanNdArray> elements(int dimensionIdx) {
+    requireHandle(nativeHandle);
+    return data.elements(dimensionIdx);
   }
 
   @Override
-  public BooleanTensor set(NdArray<Boolean> src, long... coordinates) {
-    return (BooleanTensor)super.set(src, coordinates);
+  public NdArraySequence<BooleanNdArray> scalars() {
+    requireHandle(nativeHandle);
+    return data.scalars();
   }
 
   @Override
   public BooleanTensor copyTo(NdArray<Boolean> dst) {
-    return (BooleanTensor)super.copyTo(dst);
+    requireHandle(nativeHandle);
+    data.copyTo(dst);
+    return this;
   }
 
   @Override
   public BooleanTensor read(DataBuffer<Boolean> dst) {
-    return (BooleanTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public BooleanTensor read(BooleanDataBuffer dst) {
-    return (BooleanTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public BooleanTensor write(DataBuffer<Boolean> src) {
-    return (BooleanTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
   @Override
   public BooleanTensor write(BooleanDataBuffer src) {
-    return (BooleanTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
-  public BooleanTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, BooleanDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  @Override
+  public Shape shape() {
+    requireHandle(nativeHandle);
+    return data.shape();
+  }
+
+  @Override
+  public int rank() {
+    requireHandle(nativeHandle);
+    return data.rank();
   }
 
-  private final RawTensor rawTensor;
+  @Override
+  public long size() {
+    requireHandle(nativeHandle);
+    return data.size();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    requireHandle(nativeHandle);
+    return data.equals(obj);
+  }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java
index 7f4f4742ff6..18d993219c6 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/ByteTensorImpl.java
@@ -1,95 +1,143 @@
 package org.tensorflow.internal.tensor;
 
+import org.tensorflow.AbstractTensor;
 import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.ByteNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArraySequence;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.impl.dense.ByteDenseNdArray;
+import org.tensorflow.ndarray.buffer.ByteDataBuffer;
+import org.tensorflow.ndarray.index.Index;
 import org.tensorflow.tensor.ByteTensor;
 
-public class ByteTensorImpl extends ByteDenseNdArray implements ByteTensor {
+public class ByteTensorImpl extends AbstractTensor<Byte> implements ByteTensor {
 
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
+  private final ByteNdArray data;
+
+  public ByteTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape,
+      ByteDataBuffer buffer) {
+    super(nativeHandle, dataType);
+    data = NdArrays.wrap(shape, buffer);
   }
 
   @Override
-  public DataType<?> dataType() {
-    return rawTensor.dataType();
+  public byte getByte(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getByte(coordinates);
   }
 
   @Override
-  public Shape shape() {
-    return rawTensor.shape();
+  public ByteTensor setByte(byte value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setByte(value, coordinates);
+    return this;
   }
 
   @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
+  public ByteNdArray slice(Index... coordinates) {
+    requireHandle(nativeHandle);
+    return data.slice(coordinates);
   }
 
   @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
+  public ByteTensor get(long... coordinates) {
+    requireHandle(nativeHandle);
+    data.get(coordinates);
+    return this;
   }
 
   @Override
-  public void close() {
-    rawTensor.close();
+  public ByteTensor set(NdArray<Byte> src, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.set(src, coordinates);
+    return this;
   }
 
   @Override
-  public String toString() {
-    return rawTensor.toString();
+  public Byte getObject(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getObject(coordinates);
   }
 
   @Override
-  public ByteTensor setByte(byte value, long... coordinates) {
-    return (ByteTensor)super.setByte(value, coordinates);
+  public ByteTensor setObject(Byte value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setObject(value, coordinates);
+    return this;
   }
 
   @Override
-  public ByteTensor setObject(Byte value, long... coordinates) {
-    return (ByteTensor)super.setObject(value, coordinates);
+  public NdArraySequence<ByteNdArray> elements(int dimensionIdx) {
+    requireHandle(nativeHandle);
+    return data.elements(dimensionIdx);
   }
 
   @Override
-  public ByteTensor set(NdArray<Byte> src, long... coordinates) {
-    return (ByteTensor)super.set(src, coordinates);
+  public NdArraySequence<ByteNdArray> scalars() {
+    requireHandle(nativeHandle);
+    return data.scalars();
   }
 
   @Override
   public ByteTensor copyTo(NdArray<Byte> dst) {
-    return (ByteTensor)super.copyTo(dst);
+    requireHandle(nativeHandle);
+    data.copyTo(dst);
+    return this;
   }
 
   @Override
   public ByteTensor read(DataBuffer<Byte> dst) {
-    return (ByteTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public ByteTensor read(ByteDataBuffer dst) {
-    return (ByteTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public ByteTensor write(DataBuffer<Byte> src) {
-    return (ByteTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
   @Override
   public ByteTensor write(ByteDataBuffer src) {
-    return (ByteTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
-  public ByteTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, ByteDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  @Override
+  public Shape shape() {
+    requireHandle(nativeHandle);
+    return data.shape();
+  }
+
+  @Override
+  public int rank() {
+    requireHandle(nativeHandle);
+    return data.rank();
   }
 
-  private final RawTensor rawTensor;
+  @Override
+  public long size() {
+    requireHandle(nativeHandle);
+    return data.size();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    requireHandle(nativeHandle);
+    return data.equals(obj);
+  }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java
index f4da880c976..7f85d86c372 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/DoubleTensorImpl.java
@@ -1,96 +1,143 @@
 package org.tensorflow.internal.tensor;
 
+import org.tensorflow.AbstractTensor;
 import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.DoubleNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArraySequence;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
-import org.tensorflow.ndarray.impl.dense.DoubleDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
 import org.tensorflow.tensor.DoubleTensor;
 
-public class DoubleTensorImpl extends DoubleDenseNdArray implements DoubleTensor {
+public class DoubleTensorImpl extends AbstractTensor<Double> implements DoubleTensor {
 
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
+  private final DoubleNdArray data;
+
+  public DoubleTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape,
+      DoubleDataBuffer buffer) {
+    super(nativeHandle, dataType);
+    data = NdArrays.wrap(shape, buffer);
   }
 
   @Override
-  public DataType<?> dataType() {
-    return rawTensor.dataType();
+  public double getDouble(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getDouble(coordinates);
   }
 
   @Override
-  public Shape shape() {
-    return rawTensor.shape();
+  public DoubleTensor setDouble(double value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setDouble(value, coordinates);
+    return this;
   }
 
   @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
+  public DoubleNdArray slice(Index... coordinates) {
+    requireHandle(nativeHandle);
+    return data.slice(coordinates);
   }
 
   @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
+  public DoubleTensor get(long... coordinates) {
+    requireHandle(nativeHandle);
+    data.get(coordinates);
+    return this;
   }
 
   @Override
-  public void close() {
-    rawTensor.close();
+  public DoubleTensor set(NdArray<Double> src, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.set(src, coordinates);
+    return this;
   }
 
   @Override
-  public String toString() {
-    return rawTensor.toString();
+  public Double getObject(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getObject(coordinates);
   }
 
   @Override
-  public DoubleTensor setDouble(double value, long... coordinates) {
-    return (DoubleTensor)super.setDouble(value, coordinates);
+  public DoubleTensor setObject(Double value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setObject(value, coordinates);
+    return this;
   }
 
   @Override
-  public DoubleTensor setObject(Double value, long... coordinates) {
-    return (DoubleTensor)super.setObject(value, coordinates);
+  public NdArraySequence<DoubleNdArray> elements(int dimensionIdx) {
+    requireHandle(nativeHandle);
+    return data.elements(dimensionIdx);
   }
 
   @Override
-  public DoubleTensor set(NdArray<Double> src, long... coordinates) {
-    return (DoubleTensor)super.set(src, coordinates);
+  public NdArraySequence<DoubleNdArray> scalars() {
+    requireHandle(nativeHandle);
+    return data.scalars();
   }
 
   @Override
   public DoubleTensor copyTo(NdArray<Double> dst) {
-    return (DoubleTensor)super.copyTo(dst);
+    requireHandle(nativeHandle);
+    data.copyTo(dst);
+    return this;
   }
 
   @Override
   public DoubleTensor read(DataBuffer<Double> dst) {
-    return (DoubleTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public DoubleTensor read(DoubleDataBuffer dst) {
-    return (DoubleTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public DoubleTensor write(DataBuffer<Double> src) {
-    return (DoubleTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
   @Override
   public DoubleTensor write(DoubleDataBuffer src) {
-    return (DoubleTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
-  public DoubleTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, DoubleDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  @Override
+  public Shape shape() {
+    requireHandle(nativeHandle);
+    return data.shape();
   }
 
-  private final RawTensor rawTensor;
+  @Override
+  public int rank() {
+    requireHandle(nativeHandle);
+    return data.rank();
+  }
+
+  @Override
+  public long size() {
+    requireHandle(nativeHandle);
+    return data.size();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    requireHandle(nativeHandle);
+    return data.equals(obj);
+  }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java
index 7aa4e824123..e2d42bba37c 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/FloatTensorImpl.java
@@ -1,96 +1,142 @@
 package org.tensorflow.internal.tensor;
 
+import org.tensorflow.AbstractTensor;
 import org.tensorflow.DataType;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.FloatNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArraySequence;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.FloatDataBuffer;
-import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
 import org.tensorflow.tensor.FloatTensor;
 
-public class FloatTensorImpl extends FloatDenseNdArray implements FloatTensor {
+public class FloatTensorImpl extends AbstractTensor<Float> implements FloatTensor {
 
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
+  private final FloatNdArray data;
+
+  public FloatTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape,
+      FloatDataBuffer buffer) {
+    super(nativeHandle, dataType);
+    data = NdArrays.wrap(shape, buffer);
   }
 
   @Override
-  public DataType<?> dataType() {
-    return rawTensor.dataType();
+  public float getFloat(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getFloat(coordinates);
   }
 
   @Override
-  public Shape shape() {
-    return rawTensor.shape();
+  public FloatTensor setFloat(float value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setFloat(value, coordinates);
+    return this;
   }
 
   @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
+  public FloatNdArray slice(Index... coordinates) {
+    requireHandle(nativeHandle);
+    return data.slice(coordinates);
   }
 
   @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
+  public FloatTensor get(long... coordinates) {
+    requireHandle(nativeHandle);
+    data.get(coordinates);
+    return this;
   }
 
   @Override
-  public void close() {
-    rawTensor.close();
+  public FloatTensor set(NdArray<Float> src, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.set(src, coordinates);
+    return this;
   }
 
   @Override
-  public String toString() {
-    return rawTensor.toString();
+  public Float getObject(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getObject(coordinates);
   }
 
   @Override
-  public FloatTensor setFloat(float value, long... coordinates) {
-    return (FloatTensor)super.setFloat(value, coordinates);
+  public FloatTensor setObject(Float value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setObject(value, coordinates);
+    return this;
   }
 
   @Override
-  public FloatTensor setObject(Float value, long... coordinates) {
-    return (FloatTensor)super.setObject(value, coordinates);
+  public NdArraySequence<FloatNdArray> elements(int dimensionIdx) {
+    requireHandle(nativeHandle);
+    return data.elements(dimensionIdx);
   }
 
   @Override
-  public FloatTensor set(NdArray<Float> src, long... coordinates) {
-    return (FloatTensor)super.set(src, coordinates);
+  public NdArraySequence<FloatNdArray> scalars() {
+    requireHandle(nativeHandle);
+    return data.scalars();
   }
 
   @Override
   public FloatTensor copyTo(NdArray<Float> dst) {
-    return (FloatTensor)super.copyTo(dst);
+    requireHandle(nativeHandle);
+    data.copyTo(dst);
+    return this;
   }
 
   @Override
   public FloatTensor read(DataBuffer<Float> dst) {
-    return (FloatTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public FloatTensor read(FloatDataBuffer dst) {
-    return (FloatTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public FloatTensor write(DataBuffer<Float> src) {
-    return (FloatTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
   @Override
   public FloatTensor write(FloatDataBuffer src) {
-    return (FloatTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
-  public FloatTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, FloatDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  @Override
+  public Shape shape() {
+    requireHandle(nativeHandle);
+    return data.shape();
   }
 
-  private final RawTensor rawTensor;
+  @Override
+  public int rank() {
+    requireHandle(nativeHandle);
+    return data.rank();
+  }
+
+  @Override
+  public long size() {
+    requireHandle(nativeHandle);
+    return data.size();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    requireHandle(nativeHandle);
+    return data.equals(obj);
+  }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java
index 6febdda8c93..bff637e38ab 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/IntTensorImpl.java
@@ -1,96 +1,143 @@
 package org.tensorflow.internal.tensor;
 
+import org.tensorflow.AbstractTensor;
 import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.IntNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArraySequence;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.IntDataBuffer;
-import org.tensorflow.ndarray.impl.dense.IntDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
 import org.tensorflow.tensor.IntTensor;
 
-public class IntTensorImpl extends IntDenseNdArray implements IntTensor {
+public class IntTensorImpl extends AbstractTensor<Integer> implements IntTensor {
 
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
+  private final IntNdArray data;
+
+  public IntTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape,
+      IntDataBuffer buffer) {
+    super(nativeHandle, dataType);
+    data = NdArrays.wrap(shape, buffer);
   }
 
   @Override
-  public DataType<?> dataType() {
-    return rawTensor.dataType();
+  public int getInt(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getInt(coordinates);
   }
 
   @Override
-  public Shape shape() {
-    return rawTensor.shape();
+  public IntTensor setInt(int value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setInt(value, coordinates);
+    return this;
   }
 
   @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
+  public IntNdArray slice(Index... coordinates) {
+    requireHandle(nativeHandle);
+    return data.slice(coordinates);
   }
 
   @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
+  public IntTensor get(long... coordinates) {
+    requireHandle(nativeHandle);
+    data.get(coordinates);
+    return this;
   }
 
   @Override
-  public void close() {
-    rawTensor.close();
+  public IntTensor set(NdArray<Integer> src, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.set(src, coordinates);
+    return this;
   }
 
   @Override
-  public String toString() {
-    return rawTensor.toString();
+  public Integer getObject(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getObject(coordinates);
   }
 
   @Override
-  public IntTensor setInt(int value, long... coordinates) {
-    return (IntTensor)super.setInt(value, coordinates);
+  public IntTensor setObject(Integer value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setObject(value, coordinates);
+    return this;
   }
 
   @Override
-  public IntTensor setObject(Integer value, long... coordinates) {
-    return (IntTensor)super.setObject(value, coordinates);
+  public NdArraySequence<IntNdArray> elements(int dimensionIdx) {
+    requireHandle(nativeHandle);
+    return data.elements(dimensionIdx);
   }
 
   @Override
-  public IntTensor set(NdArray<Integer> src, long... coordinates) {
-    return (IntTensor)super.set(src, coordinates);
+  public NdArraySequence<IntNdArray> scalars() {
+    requireHandle(nativeHandle);
+    return data.scalars();
   }
 
   @Override
   public IntTensor copyTo(NdArray<Integer> dst) {
-    return (IntTensor)super.copyTo(dst);
+    requireHandle(nativeHandle);
+    data.copyTo(dst);
+    return this;
   }
 
   @Override
   public IntTensor read(DataBuffer<Integer> dst) {
-    return (IntTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public IntTensor read(IntDataBuffer dst) {
-    return (IntTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public IntTensor write(DataBuffer<Integer> src) {
-    return (IntTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
   @Override
   public IntTensor write(IntDataBuffer src) {
-    return (IntTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
-  public IntTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, IntDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  @Override
+  public Shape shape() {
+    requireHandle(nativeHandle);
+    return data.shape();
   }
 
-  private final RawTensor rawTensor;
+  @Override
+  public int rank() {
+    requireHandle(nativeHandle);
+    return data.rank();
+  }
+
+  @Override
+  public long size() {
+    requireHandle(nativeHandle);
+    return data.size();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    requireHandle(nativeHandle);
+    return data.equals(obj);
+  }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java
index 7dc68cf58ce..8b3436b4e77 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/LongTensorImpl.java
@@ -1,96 +1,143 @@
 package org.tensorflow.internal.tensor;
 
+import org.tensorflow.AbstractTensor;
 import org.tensorflow.DataType;
+import org.tensorflow.Tensor;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.ndarray.LongNdArray;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArraySequence;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.LongDataBuffer;
-import org.tensorflow.ndarray.impl.dense.LongDenseNdArray;
+import org.tensorflow.ndarray.index.Index;
 import org.tensorflow.tensor.LongTensor;
 
-public class LongTensorImpl extends LongDenseNdArray implements LongTensor {
+public class LongTensorImpl extends AbstractTensor<Long> implements LongTensor {
 
-  @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
+  private final LongNdArray data;
+
+  public LongTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape,
+      LongDataBuffer buffer) {
+    super(nativeHandle, dataType);
+    data = NdArrays.wrap(shape, buffer);
   }
 
   @Override
-  public DataType<?> dataType() {
-    return rawTensor.dataType();
+  public long getLong(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getLong(coordinates);
   }
 
   @Override
-  public Shape shape() {
-    return rawTensor.shape();
+  public LongTensor setLong(long value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setLong(value, coordinates);
+    return this;
   }
 
   @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
+  public LongNdArray slice(Index... coordinates) {
+    requireHandle(nativeHandle);
+    return data.slice(coordinates);
   }
 
   @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
+  public LongTensor get(long... coordinates) {
+    requireHandle(nativeHandle);
+    data.get(coordinates);
+    return this;
   }
 
   @Override
-  public void close() {
-    rawTensor.close();
+  public LongTensor set(NdArray<Long> src, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.set(src, coordinates);
+    return this;
   }
 
   @Override
-  public String toString() {
-    return rawTensor.toString();
+  public Long getObject(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getObject(coordinates);
   }
 
   @Override
-  public LongTensor setLong(long value, long... coordinates) {
-    return (LongTensor)super.setLong(value, coordinates);
+  public LongTensor setObject(Long value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setObject(value, coordinates);
+    return this;
   }
 
   @Override
-  public LongTensor setObject(Long value, long... coordinates) {
-    return (LongTensor)super.setObject(value, coordinates);
+  public NdArraySequence<LongNdArray> elements(int dimensionIdx) {
+    requireHandle(nativeHandle);
+    return data.elements(dimensionIdx);
   }
 
   @Override
-  public LongTensor set(NdArray<Long> src, long... coordinates) {
-    return (LongTensor)super.set(src, coordinates);
+  public NdArraySequence<LongNdArray> scalars() {
+    requireHandle(nativeHandle);
+    return data.scalars();
   }
 
   @Override
   public LongTensor copyTo(NdArray<Long> dst) {
-    return (LongTensor)super.copyTo(dst);
+    requireHandle(nativeHandle);
+    data.copyTo(dst);
+    return this;
   }
 
   @Override
   public LongTensor read(DataBuffer<Long> dst) {
-    return (LongTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public LongTensor read(LongDataBuffer dst) {
-    return (LongTensor)super.read(dst);
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
   public LongTensor write(DataBuffer<Long> src) {
-    return (LongTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
   @Override
   public LongTensor write(LongDataBuffer src) {
-    return (LongTensor)super.write(src);
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
-  public LongTensorImpl(TF_Tensor nativeHandle, DataType<?> dataType, Shape shape, LongDataBuffer buffer) {
-    super(buffer, shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
+  @Override
+  public Shape shape() {
+    requireHandle(nativeHandle);
+    return data.shape();
   }
 
-  private final RawTensor rawTensor;
+  @Override
+  public int rank() {
+    requireHandle(nativeHandle);
+    return data.rank();
+  }
+
+  @Override
+  public long size() {
+    requireHandle(nativeHandle);
+    return data.size();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    requireHandle(nativeHandle);
+    return data.equals(obj);
+  }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/RawTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/RawTensor.java
deleted file mode 100644
index 98b9720b727..00000000000
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/RawTensor.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package org.tensorflow.internal.tensor;
-
-import static org.tensorflow.internal.c_api.global.tensorflow.TF_TensorByteSize;
-
-import org.bytedeco.javacpp.PointerScope;
-import org.tensorflow.DataType;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
-import org.tensorflow.internal.c_api.TF_Tensor;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
-
-class RawTensor<T> {
-
-  public TF_Tensor nativeHandle() {
-    if (nativeHandle.isNull()) {
-      throw new IllegalStateException("Tensor has been already released");
-    }
-    return nativeHandle;
-  }
-
-  public DataType<?> dataType() {
-    return dtype;
-  }
-
-  public Shape shape() {
-    return shape;
-  }
-
-  public long numBytes() {
-    return TF_TensorByteSize(nativeHandle);
-  }
-
-  public ByteDataBuffer rawData() {
-    return TensorBuffers.toBytes(nativeHandle, true);
-  }
-
-  public void close() {
-    tensorScope.close();
-  }
-
-  /** Returns a string describing the type and shape of the Tensor. */
-  @Override
-  public String toString() {
-    return String.format("%s tensor with shape %s", dataType().toString(), shape());
-  }
-
-  private final PointerScope tensorScope = new PointerScope();
-  private final TF_Tensor nativeHandle;
-  private final DataType<?> dtype;
-  private final Shape shape;
-
-  RawTensor(TF_Tensor nativeHandle, DataType<?> dtype, Shape shape) {
-    this.nativeHandle = nativeHandle;
-    this.dtype = dtype;
-    this.shape = shape;
-    this.tensorScope.attach(nativeHandle);
-  }
-}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/StringTensorImpl.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/StringTensorImpl.java
index 3ee3966a22f..4a1cd3333e5 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/StringTensorImpl.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/internal/tensor/StringTensorImpl.java
@@ -1,101 +1,132 @@
 package org.tensorflow.internal.tensor;
 
+import org.tensorflow.AbstractTensor;
 import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.tensor.buffer.ByteSequenceTensorBuffer;
 import org.tensorflow.internal.c_api.TF_Tensor;
+import org.tensorflow.internal.tensor.buffer.ByteSequenceTensorBuffer;
 import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArraySequence;
 import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.layout.DataLayout;
-import org.tensorflow.ndarray.impl.dense.DenseNdArray;
+import org.tensorflow.ndarray.index.Index;
 import org.tensorflow.tensor.StringTensor;
 
-public class StringTensorImpl extends DenseNdArray<String> implements StringTensor {
+public class StringTensorImpl extends AbstractTensor<String> implements StringTensor {
+
+  private final ByteSequenceTensorBuffer rawBuffer;
+  private final NdArray<String> data;
+
+  public StringTensorImpl(
+      TF_Tensor nativeHandle,
+      DataType<?> dataType,
+      Shape shape,
+      DataLayout<DataBuffer<byte[]>, String> layout,
+      ByteSequenceTensorBuffer buffer
+  ) {
+    super(nativeHandle, dataType);
+    this.rawBuffer = buffer;
+    data = NdArrays.wrap(shape, layout.applyTo(buffer));
+  }
 
   @Override
   public NdArray<byte[]> asBytes() {
+    requireHandle(nativeHandle);
     return NdArrays.wrap(shape(), rawBuffer);
   }
 
   @Override
-  public TF_Tensor nativeHandle() {
-    return rawTensor.nativeHandle();
+  public NdArraySequence<? extends NdArray<String>> elements(int dimensionIdx) {
+    requireHandle(nativeHandle);
+    return data.elements(dimensionIdx);
   }
 
   @Override
-  public DataType<Tensor<String>> dataType() {
-    return rawTensor.dataType();
+  public NdArraySequence<? extends NdArray<String>> scalars() {
+    requireHandle(nativeHandle);
+    return data.scalars();
   }
 
   @Override
-  public Shape shape() {
-    return rawTensor.shape();
+  public NdArray<String> slice(Index... indices) {
+    requireHandle(nativeHandle);
+    return data.slice(indices);
   }
 
   @Override
-  public long numBytes() {
-    return rawTensor.numBytes();
+  public NdArray<String> get(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.get(coordinates);
   }
 
   @Override
-  public ByteDataBuffer rawData() {
-    return rawTensor.rawData();
+  public StringTensor set(NdArray<String> src, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.set(src, coordinates);
+    return this;
   }
 
   @Override
-  public void close() {
-    rawTensor.close();
+  public String getObject(long... coordinates) {
+    requireHandle(nativeHandle);
+    return data.getObject(coordinates);
   }
 
   @Override
-  public String toString() {
-    return rawTensor.toString();
+  public StringTensor setObject(String value, long... coordinates) {
+    requireHandle(nativeHandle);
+    data.setObject(value, coordinates);
+    return this;
   }
 
   @Override
-  public Tensor<String> setObject(String value, long... coordinates) {
-    return (Tensor<String>)super.setObject(value, coordinates);
+  public StringTensor copyTo(NdArray<String> dst) {
+    requireHandle(nativeHandle);
+    data.copyTo(dst);
+    return this;
   }
 
   @Override
-  public Tensor<String> set(NdArray<String> src, long... coordinates) {
-    return (Tensor<String>)super.set(src, coordinates);
+  public StringTensor read(DataBuffer<String> dst) {
+    requireHandle(nativeHandle);
+    data.read(dst);
+    return this;
   }
 
   @Override
-  public Tensor<String> copyTo(NdArray<String> dst) {
-    return (Tensor<String>)super.copyTo(dst);
+  public StringTensor write(DataBuffer<String> src) {
+    requireHandle(nativeHandle);
+    data.write(src);
+    return this;
   }
 
   @Override
-  public Tensor<String> read(DataBuffer<String> dst) {
-    return (Tensor<String>)super.read(dst);
+  public Shape shape() {
+    requireHandle(nativeHandle);
+    return data.shape();
   }
 
   @Override
-  public Tensor<String> write(DataBuffer<String> src) {
-    return (Tensor<String>)super.write(src);
+  public int rank() {
+    requireHandle(nativeHandle);
+    return data.rank();
   }
 
-  protected ByteSequenceTensorBuffer rawBuffer() {
-    return rawBuffer;
+  @Override
+  public long size() {
+    requireHandle(nativeHandle);
+    return data.size();
   }
 
-  public StringTensorImpl(
-      TF_Tensor nativeHandle,
-      DataType<?> dataType,
-      Shape shape,
-      DataLayout<DataBuffer<byte[]>, String> layout,
-      ByteSequenceTensorBuffer buffer
-  ) {
-    super(layout.applyTo(buffer), shape);
-    this.rawTensor = new RawTensor(nativeHandle, dataType, shape);
-    this.rawBuffer = buffer;
+  @Override
+  public boolean equals(Object obj) {
+    requireHandle(nativeHandle);
+    return data.equals(obj);
   }
 
-  private final RawTensor rawTensor;
-  private final ByteSequenceTensorBuffer rawBuffer;
+  protected ByteSequenceTensorBuffer rawBuffer() {
+    return rawBuffer;
+  }
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Operands.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Operands.java
index ac48da80326..5496eaa3d15 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Operands.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/Operands.java
@@ -30,13 +30,18 @@ public final class Operands {
    * <p>Operation wrappers need to convert back a list of inputs into an array of outputs in order
    * to build an operation, see {@link OperationBuilder#addInputList(Output[])}.
    *
+   * <p>If a valid non-null value is provided as the {@code scope} of this operand, the implementor
+   * can program additional computations before returning its output. This might be required if,
+   * for instance, the implementor has not yet been added as a node to the graph.</p>
+   *
+   * @param scope if non-null, scope that can be used an operand to produce a new output
    * @param inputs an iteration of input operands
    * @return an array of outputs
    */
-  public static Output<?>[] asOutputs(Iterable<? extends Operand<?>> inputs) {
+  public static Output<?>[] asOutputs(Scope scope, Iterable<? extends Operand<?>> inputs) {
     List<Output<?>> outputList = new ArrayList<>();
     for (Operand<?> input : inputs) {
-      outputList.add(input.asOutput());
+      outputList.add(input.asOutput(scope));
     }
     return outputList.toArray(new Output<?>[outputList.size()]);
   }
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 2fc69dd9188..e7ce5158ff0 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,6 +21,7 @@
 import org.tensorflow.Operation;
 import org.tensorflow.Output;
 import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.ndarray.BooleanNdArray;
 import org.tensorflow.ndarray.ByteNdArray;
 import org.tensorflow.ndarray.DoubleNdArray;
@@ -42,6 +43,7 @@
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.tensor.BooleanTensor;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TFloat64;
@@ -66,7 +68,7 @@
  * }</pre>
  */
 @Operator
-public final class Constant<T extends Tensor> extends RawOp implements Operand<T> {
+public final class Constant<T extends TType> extends RawOp implements Operand<T> {
 
   /**
    * Creates a constant containing a single {@code int} element.
@@ -1004,9 +1006,9 @@ public static Constant<TUint8> tensorOf(Scope scope, Shape shape, ByteDataBuffer
    *     buffer
    */
   @Endpoint
-  public static <T extends Tensor & TType> Constant<T> tensorOf(Scope scope, DataType<T> type, Shape shape,
+  public static <T extends TType> Constant<T> tensorOf(Scope scope, DataType<T> type, Shape shape,
       ByteDataBuffer data) {
-    try (T value = Tensor.of(type, shape, data)) {
+    try (T value = Tensors.of(type, shape, data)) {
       return create(scope, value);
     }
   }
@@ -1263,8 +1265,8 @@ 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
-  public static <T extends Tensor & TType> Constant<T> create(Scope scope, T tensor) {
+  @Endpoint(name = "capture")
+  public static <T extends TType> Constant<T> create(Scope scope, T tensor) {
     return new Constant<>(
         scope
             .env()
@@ -1275,7 +1277,7 @@ public static <T extends Tensor & TType> Constant<T> create(Scope scope, T tenso
   }
 
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return output;
   }
 
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 f5192697628..bda5f97cd96 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
@@ -27,6 +27,7 @@
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Adds operations to compute the partial derivatives of sum of {@code y}s w.r.t {@code x}s,
@@ -96,13 +97,15 @@ public static Gradients create(
     if (options != null) {
       for (Options opts : options) {
         if (opts.dx != null) {
-          dx = Operands.asOutputs(opts.dx);
+          dx = Operands.asOutputs(scope, opts.dx);
         }
       }
     }
-    Output<?>[] dy =
-        graph.addGradients(
-            scope.makeOpName("Gradients"), Operands.asOutputs(y), Operands.asOutputs(x), dx);
+    Output<?>[] dy = graph.addGradients(
+        scope.makeOpName("Gradients"),
+        Operands.asOutputs(scope, y),
+        Operands.asOutputs(scope, x), dx
+    );
     return new Gradients(Arrays.asList(dy));
   }
 
@@ -157,7 +160,7 @@ public List<Output<?>> dy() {
    * @param index The index of the output among the gradients added by this operation
    */
   @SuppressWarnings("unchecked")
-  public <T extends Tensor> Output<T> dy(int index) {
+  public <T extends TType> Output<T> dy(int index) {
     return (Output<T>) dy.get(index);
   }
 
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 123f7eb826b..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
@@ -17,10 +17,10 @@
 
 import org.tensorflow.Operand;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
+import org.tensorflow.types.family.TType;
 
 /**
  * Container class for core methods which add or perform several operations
@@ -45,7 +45,7 @@ private Helpers() {}
      * @return a new instance of Variable
      */
     @Endpoint(name = "variable")
-    public static <T extends Tensor> Variable<T> createVariableWithInit(Scope scope, Operand<T> init, Variable.Options... options) {
+    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);
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java
index 14bc0604ce6..a2dc0cc6b5d 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/op/core/Shapes.java
@@ -15,23 +15,21 @@
 package org.tensorflow.op.core;
 
 import java.util.Arrays;
-
 import org.tensorflow.DataType;
 import org.tensorflow.Operand;
 import org.tensorflow.Tensor;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
 import org.tensorflow.op.annotation.Operator;
-
-import org.tensorflow.op.math.FloorMod;
-
 import org.tensorflow.op.dtypes.Cast;
+import org.tensorflow.op.math.FloorMod;
 import org.tensorflow.op.math.NotEqual;
 import org.tensorflow.op.math.Sub;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.TInt64;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An operator providing methods on org.tensorflow.op.core.Shape tensors and 1d operands that
@@ -67,7 +65,7 @@ public abstract class Shapes {
    * @return the reshaped operand
    */
   @Endpoint(name = "flatten")
-  public static <T extends Tensor> Operand<T> flatten(Scope scope, Operand<T> operand) {
+  public static <T extends TType> Operand<T> flatten(Scope scope, Operand<T> operand) {
     return flatten(scope, operand, TInt32.DTYPE);
   }
 
@@ -82,7 +80,7 @@ public static <T extends Tensor> Operand<T> flatten(Scope scope, Operand<T> oper
    * @return the reshaped operand
    */
   @Endpoint(name = "flatten")
-  public static <T extends Tensor, U extends Tensor & TNumber> Operand<T> flatten(
+  public static <T extends TType, U extends TNumber> Operand<T> flatten(
       Scope scope, Operand<T> operand, DataType<U> dType) {
     Operand<U> flatShape = flatten(scope, Shape.create(scope, operand, dType), dType);
     return Reshape.create(scope, operand, flatShape);
@@ -110,7 +108,7 @@ public static Operand<TInt32> flatten(Scope scope, Shape<TInt32> shape) {
    * @return the flattened shape
    */
   @Endpoint(name = "flatten")
-  public static <U extends Tensor & TNumber> Operand<U> flatten(
+  public static <U extends TNumber> Operand<U> flatten(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return ExpandDims.create(
         scope,
@@ -140,7 +138,7 @@ public static Operand<TInt32> size(Scope scope, Shape<TInt32> shape) {
    * @return the size
    */
   @Endpoint(name = "size")
-  public static <U extends Tensor & TNumber> Operand<U> size(
+  public static <U extends TNumber> Operand<U> size(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     Slice<U> dims =
         Slice.create(
@@ -178,7 +176,7 @@ public static Operand<TInt32> size(Scope scope, Shape<TInt32> shape, Operand<TIn
    * @return the size of the specified dimension
    */
   @Endpoint(name = "size")
-  public static <U extends Tensor & TNumber> Operand<U> size(
+  public static <U extends TNumber> Operand<U> size(
       Scope scope, Shape<U> shape, Operand<U> dim, DataType<U> dType) {
     return Slice.create(
         scope,
@@ -199,7 +197,7 @@ public static <U extends Tensor & TNumber> Operand<U> size(
    * @return the size of the specified dimension
    */
   @Endpoint(name = "size")
-  public static <T extends Tensor> Operand<TInt32> size(
+  public static <T extends TType> Operand<TInt32> size(
       Scope scope, Operand<T> input, Operand<TInt32> dim) {
     return size(scope, input, dim, TInt32.DTYPE);
   }
@@ -215,7 +213,7 @@ public static <T extends Tensor> Operand<TInt32> size(
    * @return the size of the specified dimension
    */
   @Endpoint(name = "size")
-  public static <T extends Tensor, U extends Tensor & TNumber> Operand<U> size(
+  public static <T extends TType, U extends TNumber> Operand<U> size(
       Scope scope, Operand<T> input, Operand<U> dim, DataType<U> dType) {
     return size(scope, Shape.create(scope, input, dType), dim, dType);
   }
@@ -242,7 +240,7 @@ public static Operand<TInt32> numDimensions(Scope scope, Shape<TInt32> shape) {
    * @return the number of dimensions
    */
   @Endpoint(name = "numDimensions")
-  public static <U extends Tensor & TNumber> Operand<U> numDimensions(
+  public static <U extends TNumber> Operand<U> numDimensions(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return Size.create(scope, shape, dType);
   }
@@ -257,7 +255,7 @@ public static <U extends Tensor & TNumber> Operand<U> numDimensions(
    * @return the reshaped operand
    */
   @Endpoint(name = "reduceDims")
-  public static <T extends Tensor> Operand<T> reduceDims(
+  public static <T extends TType> Operand<T> reduceDims(
       Scope scope, Operand<T> operand, Operand<TInt32> axis) {
     return reduceDims(scope, operand, axis, TInt32.DTYPE);
   }
@@ -274,7 +272,7 @@ public static <T extends Tensor> Operand<T> reduceDims(
    * @return the reshaped operand
    */
   @Endpoint(name = "reduceDims")
-  public static <T extends Tensor, U extends Tensor & TNumber> Operand<T> reduceDims(
+  public static <T extends TType, U extends TNumber> Operand<T> reduceDims(
       Scope scope, Operand<T> operand, Operand<U> axis, DataType<U> dType) {
     Shape<U> newShape = Shape.create(scope, operand, dType);
     return Reshape.create(scope, operand, reduceDims(scope, newShape, axis, dType));
@@ -304,7 +302,7 @@ public static Operand<TInt32> reduceDims(Scope scope, Shape<TInt32> shape, Opera
    * @return the reduced shape
    */
   @Endpoint(name = "reduceDims")
-  public static <U extends Tensor & TNumber> Operand<U> reduceDims(
+  public static <U extends TNumber> Operand<U> reduceDims(
       Scope scope, Shape<U> shape, Operand<U> axis, DataType<U> dType) {
     Size<U> rank = Size.create(scope, shape, dType);
     axis = FloorMod.create(scope, axis, rank);
@@ -356,7 +354,7 @@ public static Operand<TInt32> squeeze(Scope scope, Shape<TInt32> shape) {
    * @return the squeezed shape
    */
   @Endpoint(name = "squeeze")
-  public static <U extends Tensor & TNumber> Operand<U> squeeze(
+  public static <U extends TNumber> Operand<U> squeeze(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     Operand<TBool> mask =
         NotEqual.create(scope, shape, Cast.create(scope, OnesLike.create(scope, shape), dType));
@@ -386,7 +384,7 @@ public static Operand<TInt32> head(Scope scope, Shape<TInt32> shape) {
    * @return a 1-dimensional Operand containing the Shape's first dimension
    */
   @Endpoint(name = "head")
-  public static <U extends Tensor & TNumber> Operand<U> head(
+  public static <U extends TNumber> Operand<U> head(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return take(scope, shape, Cast.create(scope, Constant.scalarOf(scope, 1), dType), dType);
   }
@@ -419,7 +417,7 @@ public static Operand<TInt32> take(Scope scope, Shape<TInt32> shape, Operand<TIn
    *     shape
    */
   @Endpoint(name = "take")
-  public static <U extends Tensor & TNumber> Operand<U> take(
+  public static <U extends TNumber> Operand<U> take(
       Scope scope, Shape<U> shape, Operand<U> n, DataType<U> dType) {
     return Slice.create(
         scope,
@@ -454,7 +452,7 @@ public static Operand<TInt32> tail(Scope scope, Shape<TInt32> shape) {
    *     Shape
    */
   @Endpoint(name = "tail")
-  public static <U extends Tensor & TNumber> Operand<U> tail(
+  public static <U extends TNumber> Operand<U> tail(
       Scope scope, Shape<U> shape, DataType<U> dType) {
     return takeLast(scope, shape, Cast.create(scope, Constant.scalarOf(scope, 1), dType), dType);
   }
@@ -470,7 +468,7 @@ public static <U extends Tensor & TNumber> Operand<U> tail(
    *     shape
    */
   @Endpoint(name = "takeLast")
-  public static <U extends Tensor & TNumber> Operand<TInt32> takeLast(
+  public static <U extends TNumber> Operand<TInt32> takeLast(
       Scope scope, Shape<TInt32> shape, Operand<TInt32> n) {
     return takeLast(scope, shape, n, TInt32.DTYPE);
   }
@@ -488,7 +486,7 @@ public static <U extends Tensor & TNumber> Operand<TInt32> takeLast(
    *     shape
    */
   @Endpoint(name = "takeLast")
-  public static <U extends Tensor & TNumber> Operand<U> takeLast(
+  public static <U extends TNumber> Operand<U> takeLast(
       Scope scope, Shape<U> shape, Operand<U> n, DataType<U> dType) {
 
     Size<U> rank = Size.create(scope, shape, dType);
@@ -548,7 +546,7 @@ public static Operand<TInt64> prepend(Scope scope, Shape<TInt64> shape, long fir
    *     representing the shape
    */
   @Endpoint(name = "prepend")
-  public static <T extends Tensor & TNumber> Operand<T> prepend(
+  public static <T extends TNumber> Operand<T> prepend(
       Scope scope, Operand<T> shape, Operand<T> shapeToPrepend) {
 
     return Concat.create(scope, Arrays.asList(shapeToPrepend, shape), Constant.scalarOf(scope, 0));
@@ -600,7 +598,7 @@ public static Operand<TInt64> append(Scope scope, Shape<TInt64> shape, long last
    *     to append
    */
   @Endpoint(name = "append")
-  public static <T extends Tensor & TNumber> Operand<T> append(
+  public static <T extends TNumber> Operand<T> append(
       Scope scope, Operand<T> shape, Operand<T> shapeToAppend) {
     return Concat.create(scope, Arrays.asList(shape, shapeToAppend), Constant.scalarOf(scope, 0));
   }
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 389be13e59d..db8fb8b9671 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
@@ -18,7 +18,6 @@
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
 import org.tensorflow.Output;
-import org.tensorflow.Tensor;
 import org.tensorflow.op.Op;
 import org.tensorflow.op.Scope;
 import org.tensorflow.op.annotation.Endpoint;
@@ -26,6 +25,7 @@
 import org.tensorflow.op.dtypes.Cast;
 import org.tensorflow.types.TString;
 import org.tensorflow.types.family.TNumber;
+import org.tensorflow.types.family.TType;
 
 /**
  * An operator creating a constant initialized with zeros of the shape given by `dims`.
@@ -38,7 +38,7 @@
  * @param <T> constant type
  */
 @Operator
-public final class Zeros<T extends Tensor> implements Op, Operand<T> {
+public final class Zeros<T extends TType> implements Op, Operand<T> {
 
   /**
    * Creates a zeroed tensor given its type and shape.
@@ -51,7 +51,7 @@ public final class Zeros<T extends Tensor> implements Op, Operand<T> {
    */
   @Endpoint
   @SuppressWarnings("unchecked")
-  public static <T extends Tensor, U extends Tensor & TNumber> Zeros<T> create(Scope scope, Operand<U> dims, DataType<T> type) {
+  public static <T extends TType, U extends TNumber> Zeros<T> create(Scope scope, Operand<U> dims, DataType<T> type) {
     Scope zerosScope = scope.withSubScope("Zeros");
     Operand<T> zero;
     if (type == TString.DTYPE) {
@@ -68,7 +68,7 @@ public Operation op() {
   }
 
   @Override
-  public Output<T> asOutput() {
+  public Output<T> asOutput(Scope scope) {
     return fill.asOutput();
   }
   
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java
index ac270e7ad0e..106e18de8f6 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/BooleanTensor.java
@@ -1,16 +1,14 @@
-package org.tensorflow.tensor;
+package org.tensorflow.types.tensor;
 
-import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.BooleanNdArray;
 import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.buffer.BooleanDataBuffer;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.impl.dense.BooleanDenseNdArray;
 
+/**
+ * A {@link Tensor} of booleans.
+ */
 public interface BooleanTensor extends BooleanNdArray, Tensor<Boolean> {
 
   @Override
@@ -37,4 +35,3 @@ public interface BooleanTensor extends BooleanNdArray, Tensor<Boolean> {
   @Override
   BooleanTensor write(BooleanDataBuffer src);
 }
-
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java
index ba18867765b..16b7825422d 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/ByteTensor.java
@@ -1,15 +1,14 @@
-package org.tensorflow.tensor;
+package org.tensorflow.types.tensor;
 
-import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.ByteNdArray;
 import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
-import org.tensorflow.ndarray.impl.dense.ByteDenseNdArray;
 
+/**
+ * A {@link Tensor} of bytes.
+ */
 public interface ByteTensor extends ByteNdArray, Tensor<Byte> {
 
   @Override
@@ -36,4 +35,3 @@ public interface ByteTensor extends ByteNdArray, Tensor<Byte> {
   @Override
   ByteTensor write(ByteDataBuffer src);
 }
-
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java
index 4f8b1b5b0c2..5f6036fa08f 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/DoubleTensor.java
@@ -1,16 +1,14 @@
-package org.tensorflow.tensor;
+package org.tensorflow.types.tensor;
 
-import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.DoubleNdArray;
 import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.DoubleDataBuffer;
-import org.tensorflow.ndarray.impl.dense.DoubleDenseNdArray;
 
+/**
+ * A {@link Tensor} of doubles.
+ */
 public interface DoubleTensor extends DoubleNdArray, Tensor<Double> {
 
   @Override
@@ -37,4 +35,3 @@ public interface DoubleTensor extends DoubleNdArray, Tensor<Double> {
   @Override
   DoubleTensor write(DoubleDataBuffer src);
 }
-
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java
index c06e9c5f0d9..c4222d8c1d6 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/FloatTensor.java
@@ -1,16 +1,14 @@
-package org.tensorflow.tensor;
+package org.tensorflow.types.tensor;
 
-import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.FloatNdArray;
 import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.FloatDataBuffer;
-import org.tensorflow.ndarray.impl.dense.FloatDenseNdArray;
 
+/**
+ * A {@link Tensor} of floats.
+ */
 public interface FloatTensor extends FloatNdArray, Tensor<Float> {
 
   @Override
@@ -37,4 +35,3 @@ public interface FloatTensor extends FloatNdArray, Tensor<Float> {
   @Override
   FloatTensor write(FloatDataBuffer src);
 }
-
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java
index 52d3930a844..67aab65f309 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/IntTensor.java
@@ -1,16 +1,14 @@
-package org.tensorflow.tensor;
+package org.tensorflow.types.tensor;
 
-import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.IntNdArray;
 import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.IntDataBuffer;
-import org.tensorflow.ndarray.impl.dense.IntDenseNdArray;
 
+/**
+ * A {@link Tensor} of integers.
+ */
 public interface IntTensor extends IntNdArray, Tensor<Integer> {
 
   @Override
@@ -37,4 +35,3 @@ public interface IntTensor extends IntNdArray, Tensor<Integer> {
   @Override
   IntTensor write(IntDataBuffer src);
 }
-
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java
index 1a29bb278d6..3d708bf869e 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/LongTensor.java
@@ -1,16 +1,14 @@
-package org.tensorflow.tensor;
+package org.tensorflow.types.tensor;
 
-import org.tensorflow.DataType;
 import org.tensorflow.Tensor;
-import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.ndarray.LongNdArray;
 import org.tensorflow.ndarray.NdArray;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.ByteDataBuffer;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 import org.tensorflow.ndarray.buffer.LongDataBuffer;
-import org.tensorflow.ndarray.impl.dense.LongDenseNdArray;
 
+/**
+ * A {@link Tensor} of longs.
+ */
 public interface LongTensor extends LongNdArray, Tensor<Long> {
 
   @Override
@@ -37,4 +35,3 @@ public interface LongTensor extends LongNdArray, Tensor<Long> {
   @Override
   LongTensor write(LongDataBuffer src);
 }
-
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java
index 78a9c2d43a0..7a74276e8df 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/tensor/StringTensor.java
@@ -1,9 +1,12 @@
-package org.tensorflow.tensor;
+package org.tensorflow.types.tensor;
 
 import org.tensorflow.Tensor;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.buffer.DataBuffer;
 
+/**
+ * A {@link Tensor} of strings.
+ */
 public interface StringTensor extends Tensor<String> {
 
   /**
@@ -12,18 +15,17 @@ public interface StringTensor extends Tensor<String> {
   NdArray<byte[]> asBytes();
 
   @Override
-  Tensor<String> set(NdArray<String> src, long... coordinates);
+  StringTensor set(NdArray<String> src, long... coordinates);
 
   @Override
-  Tensor<String> setObject(String value, long... coordinates);
+  StringTensor setObject(String value, long... coordinates);
 
   @Override
-  Tensor<String> copyTo(NdArray<String> dst);
+  StringTensor copyTo(NdArray<String> dst);
 
   @Override
-  Tensor<String> read(DataBuffer<String> dst);
+  StringTensor read(DataBuffer<String> dst);
 
   @Override
-  Tensor<String> write(DataBuffer<String> src);
+  StringTensor write(DataBuffer<String> src);
 }
-
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
index 6c772fa44cf..b318c943c87 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBfloat16.java
@@ -19,11 +19,11 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.FloatTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -47,7 +47,7 @@
  * <p>Note that some CPUs support the bfloat16 format natively, which can result in faster computation
  * compared to {@link TFloat16} when GPUs are not used.
  */
-public interface TBfloat16 extends FloatTensor, TFloating {
+public interface TBfloat16 extends FloatTensor, TFloating<TBfloat16, Float> {
 
   /** Type metadata */
   DataType<TBfloat16> DTYPE = DataType.create("BFLOAT16", 14, 2, TBfloat16Impl::new);
@@ -59,7 +59,7 @@ public interface TBfloat16 extends FloatTensor, TFloating {
    * @return the new tensor
    */
   static TBfloat16 scalarOf(float value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
   }
 
   /**
@@ -72,7 +72,7 @@ static TBfloat16 vectorOf(float... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -84,7 +84,7 @@ static TBfloat16 vectorOf(float... values) {
    * @return the new tensor
    */
   static TBfloat16 tensorOf(NdArray<Float> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -94,7 +94,7 @@ static TBfloat16 tensorOf(NdArray<Float> src) {
    * @return the new tensor
    */
   static TBfloat16 tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -105,7 +105,7 @@ static TBfloat16 tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TBfloat16 tensorOf(Shape shape, FloatDataBuffer data) {
-    return Tensor.of(DTYPE, shape, t -> t.write(data));
+    return Tensors.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
@@ -117,7 +117,7 @@ static TBfloat16 tensorOf(Shape shape, FloatDataBuffer data) {
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
   static TBfloat16 tensorOf(Shape shape, Consumer<TBfloat16> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
index 9d2180eb0a8..f09c8df90e1 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TBool.java
@@ -19,11 +19,11 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.BooleanTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -40,7 +40,7 @@
  * {@link DataLayouts#BOOL BOOL} layout, which may impact I/O
  * performances.
  */
-public interface TBool extends BooleanTensor, TType {
+public interface TBool extends BooleanTensor, TType<TBool, Boolean> {
 
   /** Type metadata */
   DataType<TBool> DTYPE = DataType.create("BOOL", 10, 1, TBoolImpl::new);
@@ -52,7 +52,7 @@ public interface TBool extends BooleanTensor, TType {
    * @return the new tensor
    */
   static TBool scalarOf(boolean value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setBoolean(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setBoolean(value));
   }
 
   /**
@@ -65,7 +65,7 @@ static TBool vectorOf(boolean... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -77,7 +77,7 @@ static TBool vectorOf(boolean... values) {
    * @return the new tensor
    */
   static TBool tensorOf(NdArray<Boolean> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -87,7 +87,7 @@ static TBool tensorOf(NdArray<Boolean> src) {
    * @return the new tensor
    */
   static TBool tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -98,7 +98,7 @@ static TBool tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TBool tensorOf(Shape shape, BooleanDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+    return Tensors.of(DTYPE, shape, d -> d.write(data));
   }
 
   /**
@@ -110,7 +110,7 @@ static TBool tensorOf(Shape shape, BooleanDataBuffer data) {
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
   static TBool tensorOf(Shape shape, Consumer<TBool> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
index fa4673830b3..5126c7caff8 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat16.java
@@ -19,11 +19,11 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.FloatTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -44,7 +44,7 @@
  * CPUs do not support this format natively. For CPU computation on 16-bit floats, the {@link TBfloat16}
  * tensor type might be a better option.
  */
-public interface TFloat16 extends FloatTensor, TFloating {
+public interface TFloat16 extends FloatTensor, TFloating<TFloat16, Float> {
 
   /** Type metadata */
   DataType<TFloat16> DTYPE = DataType.create("FLOAT16", 19, 2, TFloat16Impl::new);
@@ -56,7 +56,7 @@ public interface TFloat16 extends FloatTensor, TFloating {
    * @return the new tensor
    */
   static TFloat16 scalarOf(float value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
   }
 
   /**
@@ -69,7 +69,7 @@ static TFloat16 vectorOf(float... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -81,7 +81,7 @@ static TFloat16 vectorOf(float... values) {
    * @return the new tensor
    */
   static TFloat16 tensorOf(NdArray<Float> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -91,7 +91,7 @@ static TFloat16 tensorOf(NdArray<Float> src) {
    * @return the new tensor
    */
   static TFloat16 tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -102,7 +102,7 @@ static TFloat16 tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TFloat16 tensorOf(Shape shape, FloatDataBuffer data) {
-    return Tensor.of(DTYPE, shape, t -> t.write(data));
+    return Tensors.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
@@ -114,7 +114,7 @@ static TFloat16 tensorOf(Shape shape, FloatDataBuffer data) {
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
   static TFloat16 tensorOf(Shape shape, Consumer<TFloat16> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
index 1b48af903ce..152591cb245 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat32.java
@@ -19,11 +19,11 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.FloatTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -34,7 +34,7 @@
 /**
  * IEEE-754 single-precision 32-bit float tensor type.
  */
-public interface TFloat32 extends FloatTensor, TFloating {
+public interface TFloat32 extends FloatTensor, TFloating<TFloat32, Float> {
 
   /** Type metadata */
   DataType<TFloat32> DTYPE = DataType.create("FLOAT", 1, 4, TFloat32Impl::new);
@@ -46,7 +46,7 @@ public interface TFloat32 extends FloatTensor, TFloating {
    * @return the new tensor
    */
   static TFloat32 scalarOf(float value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setFloat(value));
   }
 
   /**
@@ -59,7 +59,7 @@ static TFloat32 vectorOf(float... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -71,7 +71,7 @@ static TFloat32 vectorOf(float... values) {
    * @return the new tensor
    */
   static TFloat32 tensorOf(NdArray<Float> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -81,7 +81,7 @@ static TFloat32 tensorOf(NdArray<Float> src) {
    * @return the new tensor
    */
   static TFloat32 tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -92,7 +92,7 @@ static TFloat32 tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TFloat32 tensorOf(Shape shape, FloatDataBuffer data) {
-    return Tensor.of(DTYPE, shape, t -> t.write(data));
+    return Tensors.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
@@ -104,7 +104,7 @@ static TFloat32 tensorOf(Shape shape, FloatDataBuffer data) {
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
   static TFloat32 tensorOf(Shape shape, Consumer<TFloat32> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
index ae92bb37b12..c75a6a5a1bc 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TFloat64.java
@@ -19,11 +19,11 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.DoubleTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -34,7 +34,7 @@
 /**
  * IEEE-754 double-precision 64-bit float tensor type.
  */
-public interface TFloat64 extends DoubleTensor, TFloating {
+public interface TFloat64 extends DoubleTensor, TFloating<TFloat64, Double> {
 
   /** Type metadata */
   DataType<TFloat64> DTYPE = DataType.create("DOUBLE", 2, 8, TFloat64Impl::new);
@@ -46,7 +46,7 @@ public interface TFloat64 extends DoubleTensor, TFloating {
    * @return the new tensor
    */
   static TFloat64 scalarOf(double value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setDouble(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setDouble(value));
   }
 
   /**
@@ -59,7 +59,7 @@ static TFloat64 vectorOf(double... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -71,7 +71,7 @@ static TFloat64 vectorOf(double... values) {
    * @return the new tensor
    */
   static TFloat64 tensorOf(NdArray<Double> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -81,7 +81,7 @@ static TFloat64 tensorOf(NdArray<Double> src) {
    * @return the new tensor
    */
   static TFloat64 tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -92,7 +92,7 @@ static TFloat64 tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TFloat64 tensorOf(Shape shape, DoubleDataBuffer data) {
-    return Tensor.of(DTYPE, shape, t -> t.write(data));
+    return Tensors.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
@@ -104,7 +104,7 @@ static TFloat64 tensorOf(Shape shape, DoubleDataBuffer data) {
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
   static TFloat64 tensorOf(Shape shape, Consumer<TFloat64> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
index 40fd74aff90..d05edddf64f 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt32.java
@@ -19,10 +19,10 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
+import org.tensorflow.Tensors;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.IntTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -33,7 +33,7 @@
 /**
  * 32-bit signed integer tensor type.
  */
-public interface TInt32 extends IntTensor, TNumber {
+public interface TInt32 extends IntTensor, TNumber<TInt32, Integer> {
 
   /** Type metadata */
   DataType<TInt32> DTYPE = DataType.create("INT32", 3, 4, TInt32Impl::new);
@@ -45,7 +45,7 @@ public interface TInt32 extends IntTensor, TNumber {
    * @return the new tensor
    */
   static TInt32 scalarOf(int value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setInt(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setInt(value));
   }
 
   /**
@@ -59,7 +59,7 @@ static TInt32 vectorOf(int... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -71,7 +71,7 @@ static TInt32 vectorOf(int... values) {
    * @return the new tensor
    */
   static TInt32 tensorOf(NdArray<Integer> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -81,7 +81,7 @@ static TInt32 tensorOf(NdArray<Integer> src) {
    * @return the new tensor
    */
   static TInt32 tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -92,7 +92,7 @@ static TInt32 tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TInt32 tensorOf(Shape shape, IntDataBuffer data) {
-    return Tensor.of(DTYPE, shape, t -> t.write(data));
+    return Tensors.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
@@ -103,7 +103,7 @@ static TInt32 tensorOf(Shape shape, IntDataBuffer data) {
    * @return the new tensor
    */
   static TInt32 tensorOf(Shape shape, Consumer<TInt32> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
index 249ea94035d..64819b6b1f9 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TInt64.java
@@ -19,11 +19,11 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.LongTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -34,7 +34,7 @@
 /**
  * 64-bit signed integer tensor type.
  */
-public interface TInt64 extends LongTensor, TNumber {
+public interface TInt64 extends LongTensor, TNumber<TInt64, Long> {
 
   /** Type metadata */
   DataType<TInt64> DTYPE = DataType.create("INT64", 9, 8, TInt64Impl::new);
@@ -46,7 +46,7 @@ public interface TInt64 extends LongTensor, TNumber {
    * @return the new tensor
    */
   static TInt64 scalarOf(long value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setLong(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setLong(value));
   }
 
   /**
@@ -59,7 +59,7 @@ static TInt64 vectorOf(long... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -71,7 +71,7 @@ static TInt64 vectorOf(long... values) {
    * @return the new tensor
    */
   static TInt64 tensorOf(NdArray<Long> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -81,7 +81,7 @@ static TInt64 tensorOf(NdArray<Long> src) {
    * @return the new tensor
    */
   static TInt64 tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -92,7 +92,7 @@ static TInt64 tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TInt64 tensorOf(Shape shape, LongDataBuffer data) {
-    return Tensor.of(DTYPE, shape, t -> t.write(data));
+    return Tensors.of(DTYPE, shape, t -> t.write(data));
   }
 
   /**
@@ -104,7 +104,7 @@ static TInt64 tensorOf(Shape shape, LongDataBuffer data) {
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
   static TInt64 tensorOf(Shape shape, Consumer<TInt64> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
index 3f574713be2..ed49c28aaf8 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TString.java
@@ -21,11 +21,11 @@
 import java.nio.charset.StandardCharsets;
 import java.util.function.Function;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
-import org.tensorflow.internal.tensor.buffer.ByteSequenceTensorBuffer;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
+import org.tensorflow.Tensors;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.StringTensorImpl;
+import org.tensorflow.internal.tensor.buffer.ByteSequenceTensorBuffer;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
@@ -44,7 +44,7 @@
  * its values initially, so TensorFlow can compute and allocate the right amount of memory. Then
  * the data in the tensor is initialized once and cannot be modified afterwards.
  */
-public interface TString extends StringTensor, TType {
+public interface TString extends StringTensor, TType<TString, String> {
 
   /**
    * Type metadata
@@ -221,12 +221,12 @@ class TStringImpl extends StringTensorImpl implements TString {
 
   @Override
   public TString using(Charset charset) {
-    return new TStringImpl(nativeHandle(), shape(), DataLayouts.ofStrings(charset), rawBuffer());
+    return new TStringImpl(nativeHandle, shape(), DataLayouts.ofStrings(charset), rawBuffer());
   }
 
   static <T> TString createTensor(NdArray<T> src, Function<T, byte[]> getBytes) {
     long size = ByteSequenceTensorBuffer.computeSize(src, getBytes);
-    return Tensor.of(TString.DTYPE, src.shape(), size, t ->
+    return Tensors.of(TString.DTYPE, src.shape(), size, t ->
         ((TStringImpl)t).rawBuffer().init(src, getBytes)
     );
   }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
index 8df15d9792f..c0cffe6d1cf 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/TUint8.java
@@ -19,11 +19,11 @@
 
 import java.util.function.Consumer;
 import org.tensorflow.DataType;
-import org.tensorflow.Tensor;
+import org.tensorflow.Tensors;
 import org.tensorflow.exceptions.TensorFlowException;
-import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.internal.c_api.TF_Tensor;
 import org.tensorflow.internal.tensor.ByteTensorImpl;
+import org.tensorflow.internal.tensor.buffer.TensorBuffers;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
@@ -34,7 +34,7 @@
 /**
  * 8-bit unsigned integer tensor type.
  */
-public interface TUint8 extends ByteTensor, TNumber {
+public interface TUint8 extends ByteTensor, TNumber<TUint8, Byte> {
 
   /** Type metadata */
   DataType<TUint8> DTYPE = DataType.create("UINT8", 4, 1, TUint8Impl::new);
@@ -46,7 +46,7 @@ public interface TUint8 extends ByteTensor, TNumber {
    * @return the new tensor
    */
   static TUint8 scalarOf(byte value) {
-    return Tensor.of(DTYPE, Shape.scalar(), t -> t.setByte(value));
+    return Tensors.of(DTYPE, Shape.scalar(), t -> t.setByte(value));
   }
 
   /**
@@ -59,7 +59,7 @@ static TUint8 vectorOf(byte... values) {
     if (values == null) {
       throw new IllegalArgumentException();
     }
-    return Tensor.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
+    return Tensors.of(DTYPE, Shape.of(values.length), t -> StdArrays.copyTo(values, t));
   }
 
   /**
@@ -71,7 +71,7 @@ static TUint8 vectorOf(byte... values) {
    * @return the new tensor
    */
   static TUint8 tensorOf(NdArray<Byte> src) {
-    return Tensor.of(DTYPE, src.shape(), src::copyTo);
+    return Tensors.of(DTYPE, src.shape(), src::copyTo);
   }
 
   /**
@@ -81,7 +81,7 @@ static TUint8 tensorOf(NdArray<Byte> src) {
    * @return the new tensor
    */
   static TUint8 tensorOf(Shape shape) {
-    return Tensor.of(DTYPE, shape);
+    return Tensors.of(DTYPE, shape);
   }
 
   /**
@@ -92,7 +92,7 @@ static TUint8 tensorOf(Shape shape) {
    * @return the new tensor
    */
   static TUint8 tensorOf(Shape shape, ByteDataBuffer data) {
-    return Tensor.of(DTYPE, shape, d -> d.write(data));
+    return Tensors.of(DTYPE, shape, d -> d.write(data));
   }
 
   /**
@@ -104,7 +104,7 @@ static TUint8 tensorOf(Shape shape, ByteDataBuffer data) {
    * @throws TensorFlowException if the tensor cannot be allocated or initialized
    */
   static TUint8 tensorOf(Shape shape, Consumer<TUint8> tensorInit) {
-    return Tensor.of(DTYPE, shape, tensorInit);
+    return Tensors.of(DTYPE, shape, tensorInit);
   }
 }
 
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
index cda67fabe5e..8e4038245d0 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TFloating.java
@@ -1,5 +1,5 @@
 package org.tensorflow.types.family;
 
-public interface TFloating extends TNumber {
+public interface TFloating<T extends TFloating, U> extends TNumber<T, U> {
 
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TNumber.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TNumber.java
index 97ee59af095..4fa2b563cae 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TNumber.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TNumber.java
@@ -32,4 +32,4 @@
  * tf.nn.softmax(tf.constant(tensor2));  // Compilation failure
  * }</pre>
  */
-public interface TNumber extends TType {}
+public interface TNumber<T extends TNumber, U> extends TType<T, U> {}
diff --git a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TType.java b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TType.java
index 8f3451b9a68..d8a8063eeb9 100644
--- a/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TType.java
+++ b/tensorflow-core/tensorflow-core-api/src/main/java/org/tensorflow/types/family/TType.java
@@ -17,6 +17,14 @@
 
 package org.tensorflow.types.family;
 
+import org.tensorflow.Operand;
+import org.tensorflow.Operation;
+import org.tensorflow.Output;
+import org.tensorflow.Tensor;
+import org.tensorflow.op.Ops;
+import org.tensorflow.op.Scope;
+import org.tensorflow.op.core.Constant;
+
 /**
  * Marker interface for all tensor types.
  *
@@ -25,13 +33,31 @@
  * between operands of a computation at compile-time. For example:
  *
  * <pre>{@code
- * Tensor<TFloat32> tensor1 = TFloat32.ofShape(2, 3, 2);
- * Tensor<TFloat32> tensor2 = TFloat32.ofShape(2, 3, 2);
- * Tensor<TInt32> tensor3 = TInt32.ofShape(2, 3, 2);
+ * TFloat32 tensor1 = TFloat32.ofShape(2, 3, 2);
+ * TFloat32 tensor2 = TFloat32.ofShape(2, 3, 2);
+ * TInt32 tensor3 = TInt32.ofShape(2, 3, 2);
  *
  * Ops tf = Ops.create();
- * tf.math.add(tf.constant(tensor1), tf.constant(tensor2));  // OK
- * tf.math.add(tf.constant(tensor1), tf.constant(tensor3));  // Compilation failure
+ * tf.math.add(tensor1, tensor2);  // OK
+ * tf.math.add(tensor1, tensor3);  // Compilation failure
  * }</pre>
  */
-public interface TType {}
+public interface TType<T extends TType, U> extends Tensor<U>, Operand<T> {
+
+  default Constant<T> toConstant(Scope scope) {
+    if (scope == null) {
+      throw new IllegalArgumentException("Scope is required");
+    }
+    return Constant.create(scope, (T)this);
+  }
+
+  @Override
+  default Output<T> asOutput(Scope scope) {
+    return toConstant(scope).asOutput();
+  }
+
+  @Override
+  default Operation op() {
+    throw new IllegalStateException("A tensor is not attached to a specific operation");
+  }
+}
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 162f1ac1c95..6aa33ef0a73 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
@@ -30,9 +30,6 @@
 import java.nio.IntBuffer;
 import java.nio.LongBuffer;
 import org.junit.jupiter.api.Test;
-import org.tensorflow.op.Ops;
-import org.tensorflow.ndarray.Shape;
-import org.tensorflow.ndarray.buffer.DataBuffers;
 import org.tensorflow.ndarray.BooleanNdArray;
 import org.tensorflow.ndarray.DoubleNdArray;
 import org.tensorflow.ndarray.FloatNdArray;
@@ -40,7 +37,10 @@
 import org.tensorflow.ndarray.LongNdArray;
 import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.NdArrays;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.StdArrays;
+import org.tensorflow.ndarray.buffer.DataBuffers;
+import org.tensorflow.op.Ops;
 import org.tensorflow.types.TBool;
 import org.tensorflow.types.TFloat32;
 import org.tensorflow.types.TFloat64;
@@ -71,14 +71,14 @@ public void createWithRawData() {
 
     // validate creating a tensor using a raw data byte buffers
     {
-      try (TBool t = Tensor.of(TBool.DTYPE, bools_shape, DataBuffers.of(bools_))) {
+      try (TBool t = Tensors.of(TBool.DTYPE, bools_shape, DataBuffers.of(bools_))) {
         boolean[] actual = new boolean[bools_.length];
         t.read(DataBuffers.of(actual));
         assertArrayEquals(bools, actual);
       }
 
       // note: the buffer is expected to contain raw TF_STRING (as per C API)
-      try (TString t = Tensor.of(TString.DTYPE, strings_shape, DataBuffers.of(strings_))) {
+      try (TString t = Tensors.of(TString.DTYPE, strings_shape, DataBuffers.of(strings_))) {
         assertEquals(strings, t.getObject());
       }
     }
@@ -95,7 +95,7 @@ public void createWithRawData() {
     }
 
     // validate shape checking
-    try (TBool t = Tensor.of(TBool.DTYPE, Shape.of(bools_.length * 2), DataBuffers.of(bools_))) {
+    try (TBool t = Tensors.of(TBool.DTYPE, Shape.of(bools_.length * 2), DataBuffers.of(bools_))) {
       fail("should have failed on incompatible buffer");
     } catch (IllegalArgumentException e) {
       // expected
@@ -445,43 +445,31 @@ public void tensorWithZeroDimension() {
 
   @Test
   public void allocateTensorWithSize() {
-    try (TInt32 t = Tensor.of(TInt32.DTYPE, Shape.of(2, 2, 2), 8 * TInt32.DTYPE.byteSize())) {
+    try (TInt32 t = Tensors.of(TInt32.DTYPE, Shape.of(2, 2, 2), 8 * TInt32.DTYPE.byteSize())) {
       // ok
     }
-    try (TInt32 t = Tensor.of(TInt32.DTYPE, Shape.of(2, 2, 2), 9 * TInt32.DTYPE.byteSize())) {
+    try (TInt32 t = Tensors.of(TInt32.DTYPE, Shape.of(2, 2, 2), 9 * TInt32.DTYPE.byteSize())) {
       // ok (size requested is larger that minimum space required)
     }
     try {
-      Tensor.of(TInt32.DTYPE, Shape.of(2, 2, 2), 8 * TInt32.DTYPE.byteSize() - 1);
+      Tensors.of(TInt32.DTYPE, Shape.of(2, 2, 2), 8 * TInt32.DTYPE.byteSize() - 1);
       fail();
     } catch (IllegalArgumentException e) {
       // as expected
     }
   }
 
-  @Test
-  public void useAfterClose() {
-    int n = 4;
-    Tensor<?> t = TInt32.scalarOf(n);
-    t.close();
-    try {
-      t.data();
-    } catch (IllegalStateException e) {
-      // The expected exception.
-    }
-  }
-
   @Test
   public void eagerTensorIsReleasedAfterSessionIsClosed() {
     TInt32 sum;
     try (EagerSession session = EagerSession.create()) {
       Ops tf = Ops.create(session);
       sum = tf.math.add(tf.constant(10), tf.constant(20)).asTensor();
-      sum.nativeHandle(); // does not throw
+      ((AbstractTensor)sum).nativeHandle(); // does not throw
       assertEquals(30, sum.getInt());
     }
     try {
-      sum.nativeHandle();
+      ((AbstractTensor)sum).nativeHandle();
       fail("Tensor native handle should have been closed by ending eager session");
     } catch (IllegalStateException e) {
       // as expected
@@ -504,7 +492,7 @@ public void fromHandle() {
     // close() on both Tensors.
     final FloatNdArray matrix = StdArrays.ndCopyOf(new float[][]{{1, 2, 3}, {4, 5, 6}});
     try (TFloat32 src = TFloat32.tensorOf(matrix)) {
-      TFloat32 cpy = Tensors.fromHandle(src.nativeHandle()).expect(TFloat32.DTYPE);
+      TFloat32 cpy = Tensors.fromHandle(((AbstractTensor)src).nativeHandle()).expect(TFloat32.DTYPE);
       assertEquals(src.dataType(), cpy.dataType());
       assertEquals(src.shape().numDimensions(), cpy.shape().numDimensions());
       assertEquals(src.shape(), cpy.shape());
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 bc3e418e6f4..f2c27c4cdf0 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
@@ -31,7 +31,7 @@ public void createOutputArrayFromOperandList() {
     try (Graph g = new Graph()) {
       Ops tf = Ops.create(g);
       Split<?> split = tf.split(tf.constant(0), tf.array(0, 1, 2), 3L);
-      Output<?>[] array = Operands.asOutputs(split.output());
+      Output<?>[] array = Operands.asOutputs(tf.scope(), split.output());
       assertEquals(split.output().size(), array.length);
       assertSame(array[0], split.output().get(0));
       assertSame(array[1], split.output().get(1));
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java
index 288c7d7b18b..af3523c9e28 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/ScopeTest.java
@@ -25,6 +25,7 @@
 import org.tensorflow.Session;
 import org.tensorflow.Tensor;
 import org.tensorflow.types.TInt32;
+import org.tensorflow.types.family.TType;
 
 /** Unit tests for {@link org.tensorflow.op.Scope}. */
 public class ScopeTest {
@@ -177,7 +178,7 @@ public void composite() {
   }
 
   // "handwritten" sample operator classes
-  private static final class Const<T extends Tensor> {
+  private static final class Const<T extends TType> {
     private final Output<T> output;
 
     static Const<TInt32> create(Scope s, int v) {
@@ -188,7 +189,7 @@ static Const<TInt32> create(Scope s, int[] v) {
       return create(s, TInt32.vectorOf(v));
     }
 
-    static <T extends Tensor> Const<T> create(Scope s, T value) {
+    static <T extends TType> Const<T> create(Scope s, T value) {
       return new Const<>(
           s.env()
               .opBuilder("Const", s.makeOpName("Const"))
@@ -207,10 +208,10 @@ Output<T> output() {
     }
   }
 
-  private static final class Mean<T extends Tensor> {
+  private static final class Mean<T extends TType> {
     private final Output<T> output;
 
-    static <T extends Tensor> Mean<T> create(Scope s, Output<T> input, Output<T> reductionIndices) {
+    static <T extends TType> Mean<T> create(Scope s, Output<T> input, Output<T> reductionIndices) {
       return new Mean<>(
           s.env()
               .opBuilder("Mean", s.makeOpName("Mean"))
@@ -229,10 +230,10 @@ Output<T> output() {
     }
   }
 
-  private static final class SquaredDifference<T extends Tensor> {
+  private static final class SquaredDifference<T extends TType> {
     private final Output<T> output;
 
-    static <T extends Tensor> SquaredDifference<T> create(Scope s, Output<T> x, Output<T> y) {
+    static <T extends TType> SquaredDifference<T> create(Scope s, Output<T> x, Output<T> y) {
       return new SquaredDifference<>(
           s.env()
               .opBuilder("SquaredDifference", s.makeOpName("SquaredDifference"))
@@ -251,7 +252,7 @@ Output<T> output() {
     }
   }
 
-  private static final class Variance<T extends Tensor> {
+  private static final class Variance<T extends TType> {
     private final Output<T> output;
 
     static Variance<TInt32> create(Scope base, Output<TInt32> x) {
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ConstantTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ConstantTest.java
index 266a62bd1ed..cd9f4c94a24 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ConstantTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/op/core/ConstantTest.java
@@ -18,11 +18,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.DoubleBuffer;
-import java.nio.FloatBuffer;
-import java.nio.IntBuffer;
-import java.nio.LongBuffer;
 import org.junit.jupiter.api.Test;
 import org.tensorflow.AutoCloseableList;
 import org.tensorflow.Graph;
@@ -64,8 +59,8 @@ public void createInts() {
       Constant<TInt32> op2 = Constant.tensorOf(scope, array);
       try (AutoCloseableList<Tensor<?>> t =
           new AutoCloseableList<>(sess.runner().fetch(op1).fetch(op2).run())) {
-        assertEquals(array, t.get(0).expect(TInt32.DTYPE).data());
-        assertEquals(array, t.get(1).expect(TInt32.DTYPE).data());
+        assertEquals(array, t.get(0).expect(TInt32.DTYPE));
+        assertEquals(array, t.get(1).expect(TInt32.DTYPE));
       }
     }
   }
@@ -83,8 +78,8 @@ public void createFloats() {
       Constant<TFloat32> op2 = Constant.tensorOf(scope, array);
       try (AutoCloseableList<Tensor<?>> t =
           new AutoCloseableList<>(sess.runner().fetch(op1).fetch(op2).run())) {
-        assertEquals(array, t.get(0).expect(TFloat32.DTYPE).data());
-        assertEquals(array, t.get(1).expect(TFloat32.DTYPE).data());
+        assertEquals(array, t.get(0).expect(TFloat32.DTYPE));
+        assertEquals(array, t.get(1).expect(TFloat32.DTYPE));
       }
     }
   }
@@ -102,8 +97,8 @@ public void createDoubles() {
       Constant<TFloat64> op2 = Constant.tensorOf(scope, array);
       try (AutoCloseableList<Tensor<?>> t =
           new AutoCloseableList<>(sess.runner().fetch(op1).fetch(op2).run())) {
-        assertEquals(array, t.get(0).expect(TFloat64.DTYPE).data());
-        assertEquals(array, t.get(1).expect(TFloat64.DTYPE).data());
+        assertEquals(array, t.get(0).expect(TFloat64.DTYPE));
+        assertEquals(array, t.get(1).expect(TFloat64.DTYPE));
       }
     }
   }
@@ -121,8 +116,8 @@ public void createLongs() {
       Constant<TInt64> op2 = Constant.tensorOf(scope, array);
       try (AutoCloseableList<Tensor<?>> t =
           new AutoCloseableList<>(sess.runner().fetch(op1).fetch(op2).run())) {
-        assertEquals(array, t.get(0).expect(TInt64.DTYPE).data());
-        assertEquals(array, t.get(1).expect(TInt64.DTYPE).data());
+        assertEquals(array, t.get(0).expect(TInt64.DTYPE));
+        assertEquals(array, t.get(1).expect(TInt64.DTYPE));
       }
     }
   }
@@ -140,8 +135,8 @@ public void createStrings() throws IOException {
       Constant<TString> op2 = Constant.tensorOf(scope, array);
       try (AutoCloseableList<Tensor<?>> t =
           new AutoCloseableList<>(sess.runner().fetch(op1).fetch(op2).run())) {
-        assertEquals(array, t.get(0).expect(TString.DTYPE).data());
-        assertEquals(array, t.get(1).expect(TString.DTYPE).data());
+        assertEquals(array, t.get(0).expect(TString.DTYPE));
+        assertEquals(array, t.get(1).expect(TString.DTYPE));
       }
     }
   }
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 de4dc09035f..3c7dbea1450 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
@@ -20,19 +20,22 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.junit.jupiter.api.Test;
+import org.tensorflow.DataType;
 import org.tensorflow.EagerSession;
-import org.tensorflow.Tensor;
-import org.tensorflow.op.Ops;
-import org.tensorflow.op.core.Constant;
-import org.tensorflow.op.math.Sub;
-import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.IntNdArray;
+import org.tensorflow.ndarray.NdArray;
 import org.tensorflow.ndarray.NdArrays;
+import org.tensorflow.ndarray.Shape;
 import org.tensorflow.ndarray.index.Indices;
+import org.tensorflow.op.Ops;
+import org.tensorflow.op.core.Constant;
+import org.tensorflow.op.math.Add;
+import org.tensorflow.op.math.Pow;
+import org.tensorflow.op.math.Sub;
 import org.tensorflow.tensor.IntTensor;
-import org.tensorflow.types.family.TType;
+import org.tensorflow.types.family.TNumber;
 
-abstract class NumericTypesTestBase<T extends Tensor<U> & TType, U> {
+abstract class NumericTypesTestBase<T extends TNumber, U> {
 
   @Test
   public void initializeTensorsWithZeros() {
@@ -46,27 +49,31 @@ public void initializeTensorsWithZeros() {
       Ops tf = Ops.create(session);
 
       // Initialize tensor memory with zeros and take a snapshot
-      tensor.scalars().forEach(scalar -> scalar.setObject(valueOf(0)));
-      Constant<T> x = tf.constant(tensor);
+      tensor.scalars().forEach(scalar -> ((NdArray<U>)scalar).setObject(valueOf(0)));
+      Constant<T> x = tf.capture(tensor);
 
       // Initialize the same tensor memory with ones and take a snapshot
-      tensor.scalars().forEach(scalar -> scalar.setObject(valueOf(1)));
-      Constant<T> y = tf.constant(tensor);
+      tensor.scalars().forEach(scalar -> ((NdArray<U>)scalar).setObject(valueOf(1)));
+      Constant<T> y = tf.capture(tensor);
 
       // Subtract y from x and validate the result
       Sub<T> sub = tf.math.sub(x, y);
       sub.asTensor().scalars().forEach(scalar ->
-          assertEquals(valueOf(-1), scalar.getObject())
+          assertEquals(valueOf(-1), ((NdArray<U>)scalar).getObject())
       );
     }
   }
 
   @Test
-  public void genericTest() {
-    IntNdArray heapData = NdArrays.vectorOf(0, 1, 2, 3);
+  public void setAndCompute() {
+    NdArray<U> heapData = allocateNdArray(Shape.of(4))
+        .setObject(valueOf(0), 0)
+        .setObject(valueOf(1), 1)
+        .setObject(valueOf(2), 2)
+        .setObject(valueOf(3), 3);
 
     // Creates a 2x2 matrix
-    try (IntTensor tensor = TInt32.tensorOf(Shape.of(2, 2))) {
+    try (T tensor = allocateTensor(Shape.of(2, 2))) {
 
       // Copy first 2 values of the vector to the first row of the matrix
       tensor.set(heapData.slice(Indices.range(0, 2)), 0);
@@ -74,35 +81,36 @@ public void genericTest() {
       // Copy values at an odd position in the vector as the second row of the matrix
       tensor.set(heapData.slice(Indices.odd()), 1);
 
-      assertEquals(0, tensor.getInt(0, 0));
-      assertEquals(1, tensor.getInt(0, 1));
-      assertEquals(1, tensor.getInt(1, 0));
-      assertEquals(3, tensor.getInt(1, 1));
+      assertEquals(valueOf(0), tensor.getObject(0, 0));
+      assertEquals(valueOf(1), tensor.getObject(0, 1));
+      assertEquals(valueOf(1), tensor.getObject(1, 0));
+      assertEquals(valueOf(3), tensor.getObject(1, 1));
 
       // Read rows of the tensor in reverse order
-      IntNdArray reversedTensorData = tensor.slice(Indices.all(), Indices.flip());
+      NdArray<U> flippedData = tensor.slice(Indices.flip(), Indices.flip());
 
-      assertEquals(1, reversedTensorData.getInt(0, 0));
-      assertEquals(0, reversedTensorData.getInt(0, 1));
-      assertEquals(3, reversedTensorData.getInt(1, 0));
-      assertEquals(1, reversedTensorData.getInt(1, 1));
+      assertEquals(valueOf(3), flippedData.getObject(0, 0));
+      assertEquals(valueOf(1), flippedData.getObject(0, 1));
+      assertEquals(valueOf(1), flippedData.getObject(1, 0));
+      assertEquals(valueOf(0), flippedData.getObject(1, 1));
 
       try (EagerSession session = EagerSession.create()) {
         Ops tf = Ops.create(session);
 
-        // Compute the power of the tensor by itself
-        Constant<TInt32> x = tf.constant(tensor);
-        IntNdArray result = tf.math.pow(x, x).data();
+        Add<T> add = tf.math.add(tensor, tensor);
+        T result = add.asTensor();
 
-        // Validate result by computing the same operation in Java
-        tensor.scalars().forEachIndexed((coords, s) ->
-          assertEquals(Math.pow(s.getInt(), s.getInt()), result.getInt(coords), 1e-7f)
-        );
+        assertEquals(valueOf(0), result.getObject(0, 0));
+        assertEquals(valueOf(2), result.getObject(0, 1));
+        assertEquals(valueOf(2), result.getObject(1, 0));
+        assertEquals(valueOf(6), result.getObject(1, 1));
       }
     }
   }
 
   abstract T allocateTensor(Shape shape);
 
+  abstract NdArray<U> allocateNdArray(Shape shape);
+
   abstract U valueOf(Integer value);
 }
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java
index 1ef6a24fc8b..70051fd1fc7 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TBfloat16Test.java
@@ -18,6 +18,8 @@
 package org.tensorflow.types;
 
 import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 
 public class TBfloat16Test extends NumericTypesTestBase<TBfloat16, Float> {
@@ -27,6 +29,11 @@ TBfloat16 allocateTensor(Shape shape) {
     return TBfloat16.tensorOf(shape);
   }
 
+  @Override
+  NdArray<Float> allocateNdArray(Shape shape) {
+    return NdArrays.ofFloats(shape);
+  }
+
   @Override
   Float valueOf(Integer value) {
     return value.floatValue();
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java
index b0b2fa908f0..7fd65ba9654 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat16Test.java
@@ -18,6 +18,8 @@
 package org.tensorflow.types;
 
 import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 
 public class TFloat16Test extends NumericTypesTestBase<TFloat16, Float> {
@@ -27,6 +29,11 @@ TFloat16 allocateTensor(Shape shape) {
     return TFloat16.tensorOf(shape);
   }
 
+  @Override
+  NdArray<Float> allocateNdArray(Shape shape) {
+    return NdArrays.ofFloats(shape);
+  }
+
   @Override
   Float valueOf(Integer value) {
     return value.floatValue();
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java
index 21ef1586d12..938179ab8f3 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat32Test.java
@@ -18,6 +18,8 @@
 package org.tensorflow.types;
 
 import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 
 public class TFloat32Test extends NumericTypesTestBase<TFloat32, Float> {
@@ -27,6 +29,11 @@ TFloat32 allocateTensor(Shape shape) {
     return TFloat32.tensorOf(shape);
   }
 
+  @Override
+  NdArray<Float> allocateNdArray(Shape shape) {
+    return NdArrays.ofFloats(shape);
+  }
+
   @Override
   Float valueOf(Integer value) {
     return value.floatValue();
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java
index cb9de0bea19..5eaf391692c 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TFloat64Test.java
@@ -18,6 +18,8 @@
 package org.tensorflow.types;
 
 import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 
 public class TFloat64Test extends NumericTypesTestBase<TFloat64, Double> {
@@ -27,6 +29,11 @@ TFloat64 allocateTensor(Shape shape) {
     return TFloat64.tensorOf(shape);
   }
 
+  @Override
+  NdArray<Double> allocateNdArray(Shape shape) {
+    return NdArrays.ofDoubles(shape);
+  }
+
   @Override
   Double valueOf(Integer value) {
     return value.doubleValue();
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java
index 8388c2834b2..5cae9392122 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt32Test.java
@@ -17,8 +17,19 @@
 
 package org.tensorflow.types;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.tensorflow.EagerSession;
 import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.IntNdArray;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
+import org.tensorflow.ndarray.index.Indices;
+import org.tensorflow.op.Ops;
+import org.tensorflow.op.core.Constant;
+import org.tensorflow.tensor.IntTensor;
 
 public class TInt32Test extends NumericTypesTestBase<TInt32, Integer> {
 
@@ -27,6 +38,11 @@ TInt32 allocateTensor(Shape shape) {
     return TInt32.tensorOf(shape);
   }
 
+  @Override
+  NdArray<Integer> allocateNdArray(Shape shape) {
+    return NdArrays.ofInts(shape);
+  }
+
   @Override
   Integer valueOf(Integer value) {
     return value;
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java
index 55e4c7ead87..23af4f10c6a 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TInt64Test.java
@@ -18,6 +18,8 @@
 package org.tensorflow.types;
 
 import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 
 public class TInt64Test extends NumericTypesTestBase<TInt64, Long> {
@@ -27,6 +29,11 @@ TInt64 allocateTensor(Shape shape) {
     return TInt64.tensorOf(shape);
   }
 
+  @Override
+  NdArray<Long> allocateNdArray(Shape shape) {
+    return NdArrays.ofLongs(shape);
+  }
+
   @Override
   Long valueOf(Integer value) {
     return value.longValue();
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java
index ad506498492..827f466ff5e 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TStringTest.java
@@ -67,7 +67,7 @@ public void defaultCharsetIsUtf8() {
     TString tensor = TString.tensorOf(NdArrays.scalarOfObject(BABY_CHICK));
     byte[] bytes = tensor.asBytes().getObject();
     assertArrayEquals(new byte[] { (byte)0xF0, (byte)0x9F, (byte)0x90, (byte)0xA5 }, bytes);
-    assertEquals(BABY_CHICK, tensor.data().getObject());
+    assertEquals(BABY_CHICK, tensor.getObject());
   }
 
   @Test
diff --git a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java
index eb2ddd5bd38..e2ba52ef10b 100644
--- a/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java
+++ b/tensorflow-core/tensorflow-core-api/src/test/java/org/tensorflow/types/TUint8Test.java
@@ -18,6 +18,8 @@
 package org.tensorflow.types;
 
 import org.tensorflow.Tensor;
+import org.tensorflow.ndarray.NdArray;
+import org.tensorflow.ndarray.NdArrays;
 import org.tensorflow.ndarray.Shape;
 
 public class TUint8Test extends NumericTypesTestBase<TUint8, Byte> {
@@ -27,6 +29,11 @@ TUint8 allocateTensor(Shape shape) {
     return TUint8.tensorOf(shape);
   }
 
+  @Override
+  NdArray<Byte> allocateNdArray(Shape shape) {
+    return NdArrays.ofBytes(shape);
+  }
+
   @Override
   Byte valueOf(Integer value) {
     return value.byteValue();
diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/data/DatasetIterator.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/data/DatasetIterator.java
index 9c89c1b319d..f71d04838b1 100644
--- a/tensorflow-framework/src/main/java/org/tensorflow/framework/data/DatasetIterator.java
+++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/data/DatasetIterator.java
@@ -272,7 +272,7 @@ public Iterator<List<Operand<?>>> iterator() {
 
       @Override
       public boolean hasNext() {
-        return nextOptional.hasValue().data().getBoolean();
+        return nextOptional.hasValue().asTensor().getBoolean();
       }
 
       @Override
diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/BatchDatasetTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/BatchDatasetTest.java
index 6a54cb08de6..e3c5c6ad06b 100644
--- a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/BatchDatasetTest.java
+++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/BatchDatasetTest.java
@@ -45,14 +45,10 @@ public void testEagerBatchDataset() {
 
     int count = 0;
     for (List<Operand<?>> components : dataset) {
-      try (Tensor<TInt32> batch1 =
-               components.get(0).asTensor().expect(TInt32.DTYPE);
-           Tensor<TInt32> batch2 =
-               components.get(1).asTensor().expect(TInt32.DTYPE);) {
-
-        assertEquals(testMatrix1.slice(range(count, count + 2)), batch1.data());
-        assertEquals(testMatrix2.slice(range(count, count + 2)), batch2.data());
-
+      try (TInt32 batch1 = components.get(0).asTensor(TInt32.DTYPE);
+           TInt32 batch2 = components.get(1).asTensor(TInt32.DTYPE);) {
+        assertEquals(testMatrix1.slice(range(count, count + 2)), batch1);
+        assertEquals(testMatrix2.slice(range(count, count + 2)), batch2);
         count += 2;
       }
     }
@@ -63,23 +59,16 @@ public void testDropLastBatch() {
     Ops tf = Ops.create();
     Dataset dataset = Dataset
         .fromTensorSlices(tf,
-            Arrays.asList(
-                tf.constant(testMatrix1),
-                tf.constant(testMatrix2)),
+            Arrays.asList(tf.constant(testMatrix1), tf.constant(testMatrix2)),
             Arrays.asList(TInt32.DTYPE, TInt32.DTYPE))
         .batch(3, true);
 
     int count = 0;
     for (List<Operand<?>> components : dataset) {
-
-      try (Tensor<TInt32> batch1 =
-               components.get(0).asTensor().expect(TInt32.DTYPE);
-           Tensor<TInt32> batch2 =
-               components.get(1).asTensor().expect(TInt32.DTYPE);) {
-
-        assertEquals(testMatrix1.slice(range(count, count + 3)), batch1.data());
-        assertEquals(testMatrix2.slice(range(count, count + 3)), batch2.data());
-
+      try (TInt32 batch1 = components.get(0).asTensor(TInt32.DTYPE);
+          TInt32 batch2 = components.get(1).asTensor(TInt32.DTYPE);) {
+        assertEquals(testMatrix1.slice(range(count, count + 3)), batch1);
+        assertEquals(testMatrix2.slice(range(count, count + 3)), batch2);
         count += 3;
       }
     }
@@ -90,9 +79,7 @@ public void testKeepLastBatch() {
     Ops tf = Ops.create();
     Dataset dataset = Dataset
         .fromTensorSlices(tf,
-            Arrays.asList(
-                tf.constant(testMatrix1),
-                tf.constant(testMatrix2)),
+            Arrays.asList(tf.constant(testMatrix1), tf.constant(testMatrix2)),
             Arrays.asList(TInt32.DTYPE, TInt32.DTYPE))
         .batch(3, false);
 
@@ -100,21 +87,15 @@ public void testKeepLastBatch() {
     boolean foundLastBatch = false;
 
     for (List<Operand<?>> components : dataset) {
-      try (Tensor<TInt32> batch1 =
-               components.get(0).asTensor().expect(TInt32.DTYPE);
-           Tensor<TInt32> batch2 =
-               components.get(1).asTensor().expect(TInt32.DTYPE);) {
+      try (TInt32 batch1 = components.get(0).asTensor(TInt32.DTYPE);
+           TInt32 batch2 = components.get(1).asTensor(TInt32.DTYPE);) {
         if (count == 0) {
-          assertEquals(testMatrix1.slice(range(count, count + 3)),
-              batch1.data());
-          assertEquals(testMatrix2.slice(range(count, count + 3)),
-              batch2.data());
+          assertEquals(testMatrix1.slice(range(count, count + 3)), batch1);
+          assertEquals(testMatrix2.slice(range(count, count + 3)), batch2);
           count += 3;
         } else {
-          assertEquals(testMatrix1.slice(range(count, count + 1)),
-              batch1.data());
-          assertEquals(testMatrix2.slice(range(count, count + 1)),
-              batch2.data());
+          assertEquals(testMatrix1.slice(range(count, count + 1)), batch1);
+          assertEquals(testMatrix2.slice(range(count, count + 1)), batch2);
           foundLastBatch = true;
         }
       }
diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/DatasetIteratorTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/DatasetIteratorTest.java
index 6bb6e21f330..d89419e8a3d 100644
--- a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/DatasetIteratorTest.java
+++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/DatasetIteratorTest.java
@@ -56,10 +56,10 @@ public void testGraphIteration() {
           try {
             List<Tensor<?>> outputs = session.runner().fetch(x).fetch(y).run();
 
-            try (Tensor<TInt32> xBatch = outputs.get(0).expect(TInt32.DTYPE);
-                Tensor<TInt32> yBatch = outputs.get(1).expect(TInt32.DTYPE)) {
-              assertEquals(testMatrix1.get(batches), xBatch.data());
-              assertEquals(testMatrix2.get(batches), yBatch.data());
+            try (TInt32 xBatch = outputs.get(0).expect(TInt32.DTYPE);
+                TInt32 yBatch = outputs.get(1).expect(TInt32.DTYPE)) {
+              assertEquals(testMatrix1.get(batches), xBatch);
+              assertEquals(testMatrix2.get(batches), yBatch);
               batches++;
             }
           } catch (TFOutOfRangeException e) {
@@ -82,12 +82,10 @@ public void testEagerIteration() {
     Dataset dataset = Dataset.fromTensorSlices(tf, tensors, dataTypes);
     int count = 0;
     for (List<Operand<?>> outputs : dataset) {
-      try (Tensor<TInt32> batch1 = outputs.get(0).asTensor().expect(TInt32.DTYPE);
-          Tensor<TInt32> batch2 = outputs.get(1).asTensor().expect(TInt32.DTYPE); ) {
-
-        assertEquals(testMatrix1.get(count), batch1.data());
-        assertEquals(testMatrix2.get(count), batch2.data());
-
+      try (TInt32 batch1 = outputs.get(0).asTensor(TInt32.DTYPE);
+          TInt32 batch2 = outputs.get(1).asTensor(TInt32.DTYPE); ) {
+        assertEquals(testMatrix1.get(count), batch1);
+        assertEquals(testMatrix2.get(count), batch2);
         count++;
       }
     }
diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/MapDatasetTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/MapDatasetTest.java
index 5960442ff70..c1dc0a98097 100644
--- a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/MapDatasetTest.java
+++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/MapDatasetTest.java
@@ -81,12 +81,10 @@ public void testGraphIteration() {
           try {
             List<Tensor<?>> outputs = session.runner().fetch(X).fetch(y).run();
 
-            try (Tensor<TInt32> XBatch = outputs.get(0).expect(TInt32.DTYPE);
-                Tensor<TInt32> yBatch = outputs.get(1).expect(TInt32.DTYPE)) {
-
-              assertEquals(mapped1.get(batches), XBatch.data());
-              assertEquals(mapped2.get(batches), yBatch.data());
-
+            try (TInt32 XBatch = outputs.get(0).expect(TInt32.DTYPE);
+                TInt32 yBatch = outputs.get(1).expect(TInt32.DTYPE)) {
+              assertEquals(mapped1.get(batches), XBatch);
+              assertEquals(mapped2.get(batches), yBatch);
               batches++;
             }
           } catch (TFOutOfRangeException e) {
@@ -114,12 +112,10 @@ public void testEagerIteration() {
 
     int count = 0;
     for (List<Operand<?>> outputs : dataset) {
-      try (Tensor<TInt32> XBatch = outputs.get(0).asTensor().expect(TInt32.DTYPE);
-          Tensor<TInt32> yBatch = outputs.get(1).asTensor().expect(TInt32.DTYPE); ) {
-
-        assertEquals(mapped1.get(count), XBatch.data());
-        assertEquals(mapped2.get(count), yBatch.data());
-
+      try (TInt32 XBatch = outputs.get(0).asTensor(TInt32.DTYPE);
+          TInt32 yBatch = outputs.get(1).asTensor(TInt32.DTYPE); ) {
+        assertEquals(mapped1.get(count), XBatch);
+        assertEquals(mapped2.get(count), yBatch);
         count++;
       }
     }
diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/SkipDatasetTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/SkipDatasetTest.java
index 9ff8080034d..eba3a273380 100644
--- a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/SkipDatasetTest.java
+++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/SkipDatasetTest.java
@@ -40,11 +40,10 @@ public void testEagerSkipDataset() {
 
     int count = 2;
     for (List<Operand<?>> components : dataset) {
-      try (Tensor<TInt32> batch1 = components.get(0).asTensor().expect(TInt32.DTYPE);
-          Tensor<TInt32> batch2 =
-              components.get(1).asTensor().expect(TInt32.DTYPE); ) {
-        assertEquals(testMatrix1.get(count), batch1.data());
-        assertEquals(testMatrix2.get(count), batch2.data());
+      try (TInt32 batch1 = components.get(0).asTensor(TInt32.DTYPE);
+          TInt32 batch2 = components.get(1).asTensor(TInt32.DTYPE); ) {
+        assertEquals(testMatrix1.get(count), batch1);
+        assertEquals(testMatrix2.get(count), batch2);
         count++;
       }
     }
diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/TakeDatasetTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/TakeDatasetTest.java
index 4419f4660db..e07272e3718 100644
--- a/tensorflow-framework/src/test/java/org/tensorflow/framework/data/TakeDatasetTest.java
+++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/data/TakeDatasetTest.java
@@ -41,11 +41,10 @@ public void testEagerTakeDataset() {
 
     int count = 0;
     for (List<Operand<?>> components : dataset) {
-      try (Tensor<TInt32> batch1 = components.get(0).asTensor().expect(TInt32.DTYPE);
-          Tensor<TInt32> batch2 = components.get(1).asTensor().expect(TInt32.DTYPE); ) {
-
-        assertEquals(testMatrix1.get(count), batch1.data());
-        assertEquals(testMatrix2.get(count), batch2.data());
+      try (TInt32 batch1 = components.get(0).asTensor(TInt32.DTYPE);
+          TInt32 batch2 = components.get(1).asTensor(TInt32.DTYPE); ) {
+        assertEquals(testMatrix1.get(count), batch1);
+        assertEquals(testMatrix2.get(count), batch2);
         count++;
       }
     }