Update generation

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

Author: rnett

tensorflow-core/tensorflow-core-api/pom.xml

@@ -20,7 +20,7 @@
     <javacpp.parser.skip>${native.build.skip}</javacpp.parser.skip>
     <javacpp.compiler.skip>${native.build.skip}</javacpp.compiler.skip>
     <java.module.name>org.tensorflow.core.api</java.module.name>
-    <ndarray.version>0.3.3</ndarray.version>
+    <ndarray.version>0.4.0-SNAPSHOT</ndarray.version>
     <truth.version>1.0.1</truth.version>
   </properties>
 

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

@@ -1811,55 +1811,6 @@ public <T extends TNumber> Selu<T> selu(Operand<T> features) {
     return Selu.create(scope, features);
   }
 
-  /**
-   * Computes sigmoid cross entropy given <code>logits</code>.
-   *
-   *  <p>Measures the probability error in discrete classification tasks in which each class is
-   *  independent and not mutually exclusive. For instance, one could perform multilabel
-   *  classification where a picture can contain both an elephant and a dog at the same time.
-   *
-   *  <p>For brevity, let <code>x = logits</code>, <code>z = labels</code>. The logistic loss in
-   *  pseudo-code is
-   *
-   *  <pre>
-   *  z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
-   *   = z * -log(1 / (1 + exp(-x))) + (1 - z) * -log(exp(-x) / (1 + exp(-x)))
-   *   = z * log(1 + exp(-x)) + (1 - z) * (-log(exp(-x)) + log(1 + exp(-x)))
-   *   = z * log(1 + exp(-x)) + (1 - z) * (x + log(1 + exp(-x))
-   *   = (1 - z) * x + log(1 + exp(-x))
-   *   = x - x * z + log(1 + exp(-x))
-   *  </pre>
-   *
-   *  <p>For <code>x < 0</code>, to avoid overflow in <code>exp(-x)</code>, we reformulate the above
-   *
-   *  <pre>
-   *  x - x * z + log(1 + exp(-x))
-   *   = log(exp(x)) - x * z + log(1 + exp(-x))
-   *   = - x * z + log(1 + exp(x))
-   *  </pre>
-   *
-   *  <p>Hence, to ensure stability and avoid overflow, the implementation uses this equivalent
-   *  formulation
-   *
-   *  <pre>
-   *    max(x, 0) - x * z + log(1 + exp(-abs(x)))
-   *  </pre>
-   *
-   *  <p></ode>logits</code> and <code>labels</code> must have the same type and shape.
-   *
-   *  <p>
-   *
-   * @param labels the labels
-   * @param logits the logits of type float32 or float64
-   * @param <T> the type of labels and logits
-   * @return the component-wise logistic losses.
-   * @throws IllegalArgumentException if logits' and labels' do not have the same shape
-   */
-  public <T extends TNumber> Operand<T> sigmoidCrossEntropyWithLogits(Operand<T> labels,
-      Operand<T> logits) {
-    return SigmoidCrossEntropyWithLogits.sigmoidCrossEntropyWithLogits(scope, labels, logits);
-  }
-
   /**
    * Computes softmax activations.
    *  For each batch {@code i} and class {@code j} we have
@@ -2084,30 +2035,12 @@ public <T extends TType> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long blo
    *  given row.
    *  <p>Inputs are the logits, not probabilities.
    *
-   *  <p>This op expects unscaled logits, since it performs a <code>softmax</code> on <code>logits
-   *  </code> internally for efficiency. Do not call this op with the output of <code>softmax</code>,
-   *  as it will produce incorrect results.
-   *
-   *  <p>A common use case is to have logits of shape <code>[batchSize, numClasses]</code> and have
-   *  labels of shape <code>[batchSize]</code>, but higher dimensions are supported, in which case
-   *  the <code>dim</code>-th dimension is assumed to be of size <code>numClasses</code>. <code>
-   *  logits</code> must have the <cod>dataType</cod> of <code>TFloat16</code>, <code>TFloat32</code>
-   *  , or <code>TFloat64</code>, and <code>labels</code> must have the dtype of <code>TInt32</code>
-   *  or <code>TInt64</code>.
-   *
-   * @param labels <code>Tensor</code> of shape <code>[d_0, d_1, ..., d_{r-1}]</code> (where <code>r
-   *      </code> is rank of <code>labels</code> and result) and the dataType is <code>TInt32</code>
-   *      or <code>TInt64</code>. Each entry in <code>labels</code> must be an index in <code>[0,
-   *      numClasses)</code>. Other values will raise an exception when this op is run on CPU, and
-   *      return <code>NaN</code> for corresponding loss and gradient rows on GPU.
-   * @param logits Per-label activations (typically a linear output) of shape <code>[d_0, d_1, ...,
-   *      d_{r-1}, numClasses]</code> and dataType of <code>TFloat16</code>, <code>TFloat32</code>,
-   *      or <code>TFloat64</code>. These activation energies are interpreted as unnormalized log
-   *      probabilities.
-   * @return A <code>Tensor</code> of the same shape as <code>labels</code> and of the same type as
-   *      <code>logits</code> with the softmax cross entropy loss.
-   * @throws IllegalArgumentException If logits are scalars (need to have rank >= 1) or if the rank
-   *      of the labels is not equal to the rank of the logits minus one.
+   * @param <T> data type for {@code loss} output
+   * @param features batch_size x num_classes matrix
+   * @param labels batch_size vector with values in [0, num_classes).
+   *  This is the label for the given minibatch entry.
+   * @param <T> data type for {@code SparseSoftmaxCrossEntropyWithLogits} output and operands
+   * @return a new instance of SparseSoftmaxCrossEntropyWithLogits
    */
   public <T extends TNumber> SparseSoftmaxCrossEntropyWithLogits<T> sparseSoftmaxCrossEntropyWithLogits(
       Operand<T> features, Operand<? extends TNumber> labels) {

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

@@ -371,10 +371,10 @@ public final class Ops implements WithOps {
 
   public final TpuOps tpu;
 
-  public final AudioOps audio;
-
   public final MathOps math;
 
+  public final AudioOps audio;
+
   public final SignalOps signal;
 
   public final TrainOps train;
@@ -400,8 +400,8 @@ public final class Ops implements WithOps {
     sparse = new SparseOps(this);
     bitwise = new BitwiseOps(this);
     tpu = new TpuOps(this);
-    audio = new AudioOps(this);
     math = new MathOps(this);
+    audio = new AudioOps(this);
     signal = new SignalOps(this);
     train = new TrainOps(this);
     quantization = new QuantizationOps(this);
@@ -2996,80 +2996,6 @@ public <T extends TType> ImmutableConst<T> immutableConst(Class<T> dtype, Shape
     return ImmutableConst.create(scope, dtype, shape, memoryRegionName);
   }
 
-  /**
-   * Factory method to create an operation executing all initializers of a graph.
-   *
-   *  <p>All initializers added to a graph via
-   *  {@link org.tensorflow.op.core.Init#add(Scope, Op) tf.initAdd} are grouped together as a single
-   *  unit of computation in the graph. This operation must then be added to any graph using one or
-   *  more {@link Variable variables} and executed once before running the graph so the variable
-   *  states are initialized properly.</p>
-   *
-   *  <p>When the graph is built by the same process that is running the session, the initializers
-   *  can be invoked by executing this single endpoint. For example:</p>
-   *  <pre>{@code
-   *  try (Graph g = new Graph()) {
-   *    Variable<TInt32> x = tf.variable(tf.constant(10));  // initAdd is called implicitly
-   *    Variable<TInt32> y = tf.variable(tf.constant(20));  // idem
-   *    Add<TInt32> z = tf.math.add(x, y);
-   *
-   *    try (Session s = new Session(g)) {
-   *      s.run(tf.init());  // initialize all variables
-   *
-   *      try (TInt32 t = (TInt32)s.runner().fetch(z).run().get(0)) {
-   *        assertEquals(30, t.data().getInt());
-   *      }
-   *    }
-   *  }
-   *  }</pre>
-   *
-   *  <p>When the graph is built by a separate process, the initializers can be invoked by running
-   *  the init op by its name, which defaults to {@link org.tensorflow.op.core.Init#DEFAULT_NAME}.
-   *  For example:</p>
-   *  <pre>{@code
-   *  // Building the model
-   *  try (Graph g = new Graph()) {
-   *    Variable<TInt32> x = tf.variable(tf.constant(10));  // initAdd is called implicitly
-   *    Variable<TInt32> y = tf.variable(tf.constant(20));  // idem
-   *    Add<TInt32> z = tf.withName("z").math.add(x, y);
-   *
-   *    tf.init();  // add variables initializers to the graph, as Init.DEFAULT_NAME
-   *    // ...exporting graph as a saved model...
-   *  }
-   *
-   *  ...
-   *
-   *  // Running the model
-   *  try (SavedModelBundle model = SavedModelBundle.load("/path/to/model", "train")) {
-   *    model.session().run(Init.DEFAULT_NAME);
-   *
-   *    try (TInt32 t = (TInt32)s.runner().fetch("z").run().get(0)) {
-   *      assertEquals(30, t.data().getInt());
-   *    }
-   *  }
-   *  }</pre>
-   *
-   * @return an op grouping all initializers added to the graph
-   * @throws IllegalArgumentException if the execution environment in scope is not a graph
-   */
-  public Init init() {
-    return Init.create(scope);
-  }
-
-  /**
-   * Register an op as an initializer of the graph.
-   *
-   *  <p>Registered initializers are then grouped as a single unit of computation by adding
-   *  and executing an {@link org.tensorflow.op.core.Init#create(Scope) init} operation from a graph
-   *  session.  This is a no-op if executed in an eager session.
-   *
-   * @param initializer
-   * @see org.tensorflow.op.core.Init#create(Scope) init
-   */
-  public void initAdd(Op initializer) {
-    Init.add(scope, initializer);
-  }
-
   /**
    * Table initializer that takes two tensors for keys and values respectively.
    *

tensorflow-core/tensorflow-core-generator/src/main/java/org/tensorflow/processor/operator/OperatorProcessor.java

@@ -15,14 +15,12 @@
 */
 package org.tensorflow.processor.operator;
 
-import com.squareup.javapoet.ArrayTypeName;
-import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.FieldSpec;
 import com.squareup.javapoet.JavaFile;
 import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.List;
 import javax.lang.model.element.Modifier;
 import org.tensorflow.Names;
@@ -230,18 +228,6 @@ protected TypeSpec buildTopClass(OpsSpec spec) {
             .addJavadoc("{@inheritDoc}")
             .build());
 
-    opsBuilder.addMethod(
-        MethodSpec.methodBuilder("withControlDependencies")
-            .addModifiers(Modifier.PUBLIC)
-            .addAnnotation(Override.class)
-            .addParameter(ArrayTypeName.of(Names.Op), "controls")
-            .varargs()
-            .returns(Names.Ops)
-            .addStatement(
-                "return withControlDependencies($T.asList(controls))", ClassName.get(Arrays.class))
-            .addJavadoc("{@inheritDoc}")
-            .build());
-
     opsBuilder.addMethod(
         MethodSpec.methodBuilder("withControlDependencies")
             .addModifiers(Modifier.PUBLIC)