Fix generation

Signed-off-by: Ryan Nett <[email protected]>

Author: rnett

tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/Ops.java

@@ -367,20 +367,20 @@ public final class Ops {
 
   public final SparseOps sparse;
 
-  public final TpuOps tpu;
-
   public final BitwiseOps bitwise;
 
+  public final TpuOps tpu;
+
   public final MathOps math;
 
   public final AudioOps audio;
 
   public final SignalOps signal;
 
-  public final QuantizationOps quantization;
-
   public final TrainOps train;
 
+  public final QuantizationOps quantization;
+
   private final Scope scope;
 
   private Ops(Scope scope) {
@@ -398,13 +398,13 @@ private Ops(Scope scope) {
     random = new RandomOps(this);
     strings = new StringsOps(this);
     sparse = new SparseOps(this);
-    tpu = new TpuOps(this);
     bitwise = new BitwiseOps(this);
+    tpu = new TpuOps(this);
     math = new MathOps(this);
     audio = new AudioOps(this);
     signal = new SignalOps(this);
-    quantization = new QuantizationOps(this);
     train = new TrainOps(this);
+    quantization = new QuantizationOps(this);
   }
 
   /**
@@ -8043,128 +8043,6 @@ public While whileOp(Iterable<Operand<?>> input, ConcreteFunction cond, Concrete
     return While.create(scope, input, cond, body, options);
   }
 
-  /**
-   * Wraps the XLA ConvGeneralDilated operator, documented at
-   *  https://www.tensorflow.org/performance/xla/operation_semantics#conv_convolution
-   *  .
-   *
-   * @param <W> data type for {@code output} output
-   * @param lhs the input tensor
-   * @param rhs the kernel tensor
-   * @param windowStrides the inter-window strides
-   * @param padding the padding to apply at the start and end of each input dimensions
-   * @param lhsDilation dilation to apply between input elements
-   * @param rhsDilation dilation to apply between kernel elements
-   * @param featureGroupCount number of feature groups for grouped convolution.
-   * @param dimensionNumbers a serialized xla::ConvolutionDimensionNumbers proto.
-   * @param precisionConfig a serialized xla::PrecisionConfig proto.
-   * @param preferredElementType The type of the tensor.
-   * @param <W> data type for {@code XlaConvV2} output and operands
-   * @param <V> data type for {@code XlaConvV2} output and operands
-   * @return a new instance of XlaConvV2
-   */
-  public <W extends TType, V extends TNumber> XlaConvV2<W> xlaConvV2(Operand<? extends TType> lhs,
-      Operand<? extends TType> rhs, Operand<V> windowStrides, Operand<V> padding,
-      Operand<V> lhsDilation, Operand<V> rhsDilation, Operand<V> featureGroupCount,
-      String dimensionNumbers, String precisionConfig, Class<W> preferredElementType) {
-    return XlaConvV2.create(scope, lhs, rhs, windowStrides, padding, lhsDilation, rhsDilation, featureGroupCount, dimensionNumbers, precisionConfig, preferredElementType);
-  }
-
-  /**
-   * Wraps the XLA DotGeneral operator, documented at
-   *  https://www.tensorflow.org/performance/xla/operation_semantics#dotgeneral
-   *  .
-   *
-   * @param <V> data type for {@code output} output
-   * @param lhs the LHS tensor
-   * @param rhs the RHS tensor
-   * @param dimensionNumbers a serialized xla::DotDimensionNumbers proto.
-   * @param precisionConfig a serialized xla::PrecisionConfig proto.
-   * @param preferredElementType The type of the tensor.
-   * @param <V> data type for {@code XlaDotV2} output and operands
-   * @return a new instance of XlaDotV2
-   */
-  public <V extends TType> XlaDotV2<V> xlaDotV2(Operand<? extends TType> lhs,
-      Operand<? extends TType> rhs, String dimensionNumbers, String precisionConfig,
-      Class<V> preferredElementType) {
-    return XlaDotV2.create(scope, lhs, rhs, dimensionNumbers, precisionConfig, preferredElementType);
-  }
-
-  /**
-   * Make a static dimension into a xla bounded dynamic dimension.
-   *  <pre>
-   *      The current static dimension size will become the bound and the second
-   *      operand becomes the dynamic size of the dimension.
-   *  </pre>
-   *
-   * @param <T> data type for {@code output} output
-   * @param input the input value
-   * @param dimIndex the dimIndex value
-   * @param sizeOutput the sizeOutput value
-   * @param <T> data type for {@code XlaSetDynamicDimensionSize} output and operands
-   * @return a new instance of XlaSetDynamicDimensionSize
-   */
-  public <T extends TType> XlaSetDynamicDimensionSize<T> xlaSetDynamicDimensionSize(
-      Operand<T> input, Operand<TInt32> dimIndex, Operand<TInt32> sizeOutput) {
-    return XlaSetDynamicDimensionSize.create(scope, input, dimIndex, sizeOutput);
-  }
-
-  /**
-   * An op used by XLA SPMD partitioner to switch from automatic partitioning to
-   *  manual partitioning. It annotates the input (full-shape, to be automatically
-   *  partitioned) with the same sharding used by manual partitioning, and outputs a
-   *  shard-shaped tensor to be consumed by later manually-partitioned ops. If the
-   *  shape is not evenly partitionable, the padding region will be masked with 0s.
-   *
-   * @param <T> data type for {@code output} output
-   * @param input the input value
-   * @param manualSharding the value of the manualSharding property
-   * @param <T> data type for {@code XlaSpmdFullToShardShape} output and operands
-   * @return a new instance of XlaSpmdFullToShardShape
-   */
-  public <T extends TType> XlaSpmdFullToShardShape<T> xlaSpmdFullToShardShape(Operand<T> input,
-      String manualSharding) {
-    return XlaSpmdFullToShardShape.create(scope, input, manualSharding);
-  }
-
-  /**
-   * An op used by XLA SPMD partitioner to switch from manual partitioning to
-   *  automatic partitioning. It converts the shard-shaped, manually partitioned input
-   *  into full-shaped tensor to be partitioned automatically with the same sharding
-   *  used by manual partitioning.
-   *
-   * @param <T> data type for {@code output} output
-   * @param input the input value
-   * @param manualSharding the value of the manualSharding property
-   * @param fullShape the value of the fullShape property
-   * @param <T> data type for {@code XlaSpmdShardToFullShape} output and operands
-   * @return a new instance of XlaSpmdShardToFullShape
-   */
-  public <T extends TType> XlaSpmdShardToFullShape<T> xlaSpmdShardToFullShape(Operand<T> input,
-      String manualSharding, Shape fullShape) {
-    return XlaSpmdShardToFullShape.create(scope, input, manualSharding, fullShape);
-  }
-
-  /**
-   * Wraps the XLA Sort operator, documented at
-   *  https://www.tensorflow.org/performance/xla/operation_semantics#sort
-   *  .
-   *  <p>Sorts one or more tensors, with support for custom comparator, dimension, and
-   *  is_stable attributes.
-   *
-   * @param inputs A list of {@code Tensor} of identical shape but possibly different types.
-   * @param dimension The dimension along which to sort. Must be a compile-time constant.
-   * @param comparator A comparator function to apply to 2*N scalars and returning a
-   *  boolean. N is the number of sort inputs. If you want to sort in ascending
-   *  order then the comparator should perform a less-than comparison.
-   * @param isStable Whether to use stable sort.
-   * @return a new instance of XlaVariadicSort
-   */
-  public XlaVariadicSort xlaVariadicSort(Iterable<Operand<?>> inputs, Operand<TInt32> dimension,
-      ConcreteFunction comparator, Boolean isStable) {
-    return XlaVariadicSort.create(scope, inputs, dimension, comparator, isStable);
-  }
-
   /**
    * Creates a zeroed tensor given its type and shape.
    *

tensorflow-core/tensorflow-core-api/src/gen/annotations/org/tensorflow/op/XlaOps.java

@@ -42,8 +42,11 @@
 import org.tensorflow.op.xla.SelectAndScatter;
 import org.tensorflow.op.xla.SelfAdjointEig;
 import org.tensorflow.op.xla.Send;
+import org.tensorflow.op.xla.SetDynamicDimensionSize;
 import org.tensorflow.op.xla.Sharding;
 import org.tensorflow.op.xla.Sort;
+import org.tensorflow.op.xla.SpmdFullToShardShape;
+import org.tensorflow.op.xla.SpmdShardToFullShape;
 import org.tensorflow.op.xla.Svd;
 import org.tensorflow.op.xla.While;
 import org.tensorflow.op.xla.XlaHostCompute;
@@ -52,6 +55,7 @@
 import org.tensorflow.op.xla.XlaSendToHost;
 import org.tensorflow.op.xla.XlaSetBound;
 import org.tensorflow.op.xla.XlaVariadicReduce;
+import org.tensorflow.op.xla.XlaVariadicSort;
 import org.tensorflow.types.TInt32;
 import org.tensorflow.types.family.TNumber;
 import org.tensorflow.types.family.TType;
@@ -106,7 +110,7 @@ public <T extends TType> ClusterOutput<T> clusterOutput(Operand<T> input) {
    *  https://www.tensorflow.org/performance/xla/operation_semantics#conv_convolution
    *  .
    *
-   * @param <T> data type for {@code output} output
+   * @param <W> data type for {@code output} output
    * @param lhs the input tensor
    * @param rhs the kernel tensor
    * @param windowStrides the inter-window strides
@@ -116,14 +120,16 @@ public <T extends TType> ClusterOutput<T> clusterOutput(Operand<T> input) {
    * @param featureGroupCount number of feature groups for grouped convolution.
    * @param dimensionNumbers a serialized xla::ConvolutionDimensionNumbers proto.
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
-   * @param <T> data type for {@code XlaConv} output and operands
-   * @param <U> data type for {@code XlaConv} output and operands
+   * @param preferredElementType The type of the tensor.
+   * @param <W> data type for {@code XlaConvV2} output and operands
+   * @param <V> data type for {@code XlaConvV2} output and operands
    * @return a new instance of Conv
    */
-  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);
+  public <W extends TType, V extends TNumber> Conv<W> conv(Operand<? extends TType> lhs,
+      Operand<? extends TType> rhs, Operand<V> windowStrides, Operand<V> padding,
+      Operand<V> lhsDilation, Operand<V> rhsDilation, Operand<V> featureGroupCount,
+      String dimensionNumbers, String precisionConfig, Class<W> preferredElementType) {
+    return Conv.create(scope, lhs, rhs, windowStrides, padding, lhsDilation, rhsDilation, featureGroupCount, dimensionNumbers, precisionConfig, preferredElementType);
   }
 
   /**
@@ -148,17 +154,18 @@ public Dequantize dequantize(Operand<? extends TType> input, Float minRange, Flo
    *  https://www.tensorflow.org/performance/xla/operation_semantics#dotgeneral
    *  .
    *
-   * @param <T> data type for {@code output} output
+   * @param <V> data type for {@code output} output
    * @param lhs the LHS tensor
    * @param rhs the RHS tensor
    * @param dimensionNumbers a serialized xla::DotDimensionNumbers proto.
    * @param precisionConfig a serialized xla::PrecisionConfig proto.
-   * @param <T> data type for {@code XlaDot} output and operands
+   * @param preferredElementType The type of the tensor.
+   * @param <V> data type for {@code XlaDotV2} output and operands
    * @return a new instance of Dot
    */
-  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);
+  public <V extends TType> Dot<V> dot(Operand<? extends TType> lhs, Operand<? extends TType> rhs,
+      String dimensionNumbers, String precisionConfig, Class<V> preferredElementType) {
+    return Dot.create(scope, lhs, rhs, dimensionNumbers, precisionConfig, preferredElementType);
   }
 
   /**
@@ -473,6 +480,25 @@ public Send send(Operand<? extends TType> tensor, String tensorName) {
     return Send.create(scope, tensor, tensorName);
   }
 
+  /**
+   * Make a static dimension into a xla bounded dynamic dimension.
+   *  <pre>
+   *      The current static dimension size will become the bound and the second
+   *      operand becomes the dynamic size of the dimension.
+   *  </pre>
+   *
+   * @param <T> data type for {@code output} output
+   * @param input the input value
+   * @param dimIndex the dimIndex value
+   * @param sizeOutput the sizeOutput value
+   * @param <T> data type for {@code XlaSetDynamicDimensionSize} output and operands
+   * @return a new instance of SetDynamicDimensionSize
+   */
+  public <T extends TType> SetDynamicDimensionSize<T> setDynamicDimensionSize(Operand<T> input,
+      Operand<TInt32> dimIndex, Operand<TInt32> sizeOutput) {
+    return SetDynamicDimensionSize.create(scope, input, dimIndex, sizeOutput);
+  }
+
   /**
    * An op which shards the input based on the given sharding attribute.
    *
@@ -501,6 +527,42 @@ public <T extends TType> Sort<T> sort(Operand<T> input) {
     return Sort.create(scope, input);
   }
 
+  /**
+   * An op used by XLA SPMD partitioner to switch from automatic partitioning to
+   *  manual partitioning. It annotates the input (full-shape, to be automatically
+   *  partitioned) with the same sharding used by manual partitioning, and outputs a
+   *  shard-shaped tensor to be consumed by later manually-partitioned ops. If the
+   *  shape is not evenly partitionable, the padding region will be masked with 0s.
+   *
+   * @param <T> data type for {@code output} output
+   * @param input the input value
+   * @param manualSharding the value of the manualSharding property
+   * @param <T> data type for {@code XlaSpmdFullToShardShape} output and operands
+   * @return a new instance of SpmdFullToShardShape
+   */
+  public <T extends TType> SpmdFullToShardShape<T> spmdFullToShardShape(Operand<T> input,
+      String manualSharding) {
+    return SpmdFullToShardShape.create(scope, input, manualSharding);
+  }
+
+  /**
+   * An op used by XLA SPMD partitioner to switch from manual partitioning to
+   *  automatic partitioning. It converts the shard-shaped, manually partitioned input
+   *  into full-shaped tensor to be partitioned automatically with the same sharding
+   *  used by manual partitioning.
+   *
+   * @param <T> data type for {@code output} output
+   * @param input the input value
+   * @param manualSharding the value of the manualSharding property
+   * @param fullShape the value of the fullShape property
+   * @param <T> data type for {@code XlaSpmdShardToFullShape} output and operands
+   * @return a new instance of SpmdShardToFullShape
+   */
+  public <T extends TType> SpmdShardToFullShape<T> spmdShardToFullShape(Operand<T> input,
+      String manualSharding, Shape fullShape) {
+    return SpmdShardToFullShape.create(scope, input, manualSharding, fullShape);
+  }
+
   /**
    * Computes the eigen decomposition of a batch of self-adjoint matrices
    *  (Note: Only real inputs are supported).
@@ -643,6 +705,26 @@ public <T extends TType> XlaVariadicReduce<T> xlaVariadicReduce(Iterable<Operand
     return XlaVariadicReduce.create(scope, input, initValue, dimensionsToReduce, reducer);
   }
 
+  /**
+   * Wraps the XLA Sort operator, documented at
+   *  https://www.tensorflow.org/performance/xla/operation_semantics#sort
+   *  .
+   *  <p>Sorts one or more tensors, with support for custom comparator, dimension, and
+   *  is_stable attributes.
+   *
+   * @param inputs A list of {@code Tensor} of identical shape but possibly different types.
+   * @param dimension The dimension along which to sort. Must be a compile-time constant.
+   * @param comparator A comparator function to apply to 2*N scalars and returning a
+   *  boolean. N is the number of sort inputs. If you want to sort in ascending
+   *  order then the comparator should perform a less-than comparison.
+   * @param isStable Whether to use stable sort.
+   * @return a new instance of XlaVariadicSort
+   */
+  public XlaVariadicSort xlaVariadicSort(Iterable<Operand<?>> inputs, Operand<TInt32> dimension,
+      ConcreteFunction comparator, Boolean isStable) {
+    return XlaVariadicSort.create(scope, inputs, dimension, comparator, isStable);
+  }
+
   /**
    * Get the parent {@link Ops} object.
    */