Layers phase 1

tensorflow-core/tensorflow-core-api/src/bazel/api_def/api_def_SoftmaxCrossEntropyWithLogits.pbtxt

@@ -1,6 +1,6 @@
 op {
  graph_op_name: "SoftmaxCrossEntropyWithLogits"
  endpoint {
- name: "nn.raw.SoftmaxCrossEntropyWithLogits"
+ name: "nn.SoftmaxCrossEntropyWithLogits"
  }
 }

tensorflow-core/tensorflow-core-api/src/bazel/api_def/api_def_SparseSoftmaxCrossEntropyWithLogits.pbtxt

@@ -1,6 +1,6 @@
 op {
  graph_op_name: "SparseSoftmaxCrossEntropyWithLogits"
  endpoint {
- name: "nn.raw.SparseSoftmaxCrossEntropyWithLogits"
+ name: "nn.SparseSoftmaxCrossEntropyWithLogits"
  }
 }

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

@@ -83,7 +83,6 @@
 import org.tensorflow.op.nn.Relu;
 import org.tensorflow.op.nn.Relu6;
 import org.tensorflow.op.nn.Selu;
-import org.tensorflow.op.nn.SigmoidCrossEntropyWithLogits;
 import org.tensorflow.op.nn.Softmax;
 import org.tensorflow.op.nn.SoftmaxCrossEntropyWithLogits;
 import org.tensorflow.op.nn.Softsign;
@@ -103,16 +102,13 @@
  * @see {@link Ops}
  */
 public final class NnOps {
- public final NnRawOps raw;
-
  private final Scope scope;
 
  private final Ops ops;
 
  NnOps(Ops ops) {
  this.scope = ops.scope();
  this.ops = ops;
- raw = new NnRawOps(ops);
  }
 
  /**
@@ -1797,56 +1793,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 scope The TensorFlow scope
- * @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
@@ -1864,54 +1810,20 @@ public <T extends TNumber> Softmax<T> softmax(Operand<T> logits) {
  }
 
  /**
- * Computes softmax cross entropy between <code>logits</code> and <code>labels</code>.
- *
- * <p>Measures the probability error in discrete classification tasks in which the classes are
- * mutually exclusive (each entry is in exactly one class). For example, each CIFAR-10 image is
- * labeled with one and only one label: an image can be a dog or a truck, but not both.
- *
- * <p><b>NOTE:</b>
- *
- * <p>While the classes are mutually exclusive, their probabilities need not be. All that is
- * required is that each row of <code>labels</code> is a valid probability distribution. If they
- * are not, the computation of the gradient will be incorrect.
- *
- * <p>If using exclusive <code>labels</code> (wherein one and only one class is true at a time),
- * see {@link org.tensorflow.op.NnOps#sparseSoftmaxCrossEntropyWithLogits}
+ * Computes softmax cross entropy cost and gradients to backpropagate.
+ * Inputs are the logits, not probabilities.
  *
- * <p>Usage:
- *
- * <pre>
- * Operand&lt;TFloat32&gt; logits =
- * tf.constant(new float[][] {{4.0F, 2.0F, 1.0F}, {0.0F, 5.0F, 1.0F}} );
- * Operand&lt;TFloat32&gt; labels =
- * tf.constant(new float[][] {{1.0F, 0.0F, 0.0F}, {0.0F, 0.8F, 0.2F}} );
- * Operand&lt;TFloat32&gt; output =
- * tf.nn.softmaxCrossEntropyWithLogits(labels, logits, -1);
- * // output Shape = [2]
- * // dataType = FLOAT (1)
- * // values { 0.169846, 0.824745 }
- * </pre>
- *
- * <p>Backpropagation will happen into both <code>logits</code> and <code>labels</code>. To
- * disallow backpropagation into <code>labels</code>, pass label tensors through <code>
- * tf.stopGradient</code> before feeding it to this function.
- *
- * @param scope current scope
- * @param labels Each vector along the class dimension should hold a valid probability
- * distribution e.g. for the case in which labels are of shape <code>[batch_size, num_classes]
- * </code>, each row of <code>labels[i]</code> must be a valid probability distribution.
- * @param logits Per-label activations, typically a linear output. These activation energies are
- * interpreted as unnormalized log probabilities.
- * @param axis The class dimension. -1 is the last dimension.
- * @param <T> the number type of the operands
- * @return the softmax cross entropy loss. Its type is the same as <code>logits</code> and its
- * shape is the same as <code>labels</code> except that it does not have the last dimension of
- * <code>labels</code>.
+ * @param <T> data type for {@code loss} output
+ * @param features batch_size x num_classes matrix
+ * @param labels batch_size x num_classes matrix
+ * The caller must ensure that each batch of labels represents a valid
+ * probability distribution.
+ * @param <T> data type for {@code SoftmaxCrossEntropyWithLogits} output and operands
+ * @return a new instance of SoftmaxCrossEntropyWithLogits
  */
- public <T extends TNumber, U extends TNumber> Operand<T> softmaxCrossEntropyWithLogits(
- Operand<U> labels, Operand<T> logits, int axis) {
- return SoftmaxCrossEntropyWithLogits.softmaxCrossEntropyWithLogits(scope, labels, logits, axis);
+ public <T extends TNumber> SoftmaxCrossEntropyWithLogits<T> softmaxCrossEntropyWithLogits(
+ Operand<T> features, Operand<T> labels) {
+ return SoftmaxCrossEntropyWithLogits.create(scope, features, labels);
  }
 
  /**
@@ -2098,51 +2010,23 @@ public <T extends TType> SpaceToDepth<T> spaceToDepth(Operand<T> input, Long blo
  }
 
  /**
- * Computes sparse softmax cross entropy between <code>logits</code> and <code>labels</code>.
- *
- * <p>Measures the probability error in discrete classification tasks in which the classes are
- * mutually exclusive (each entry is in exactly one class). For example, each CIFAR-10 image is
- * labeled with one and only one label: an image can be a dog or a truck, but not both.
- *
- * <p><b>NOTE:</b>
- *
- * <p>For this operation, the probability of a given label is considered exclusive. That is, soft
- * classes are not allowed, and the <code>labels</code> vector must provide a single specific
- * index for the true class for each row of <code>logits</code> (each minibatch entry). For soft
- * softmax classification with a probability distribution for each entry, {@link
- * org.tensorflow.op.NnOps#softmaxCrossEntropyWithLogits}.
- *
- * <p><b>WARNING:</b>
- *
- * <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 scope current scope
- * @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.
- */
- public <T extends TNumber, U extends TNumber> Operand sparseSoftmaxCrossEntropyWithLogits(
- Operand<T> labels, Operand<U> logits) {
- return SparseSoftmaxCrossEntropyWithLogits.sparseSoftmaxCrossEntropyWithLogits(scope, labels, logits);
+ * Computes softmax cross entropy cost and gradients to backpropagate.
+ * Unlike {@code SoftmaxCrossEntropyWithLogits}, this operation does not accept
+ * a matrix of label probabilities, but rather a single label per row
+ * of features. This label is considered to have probability 1.0 for the
+ * given row.
+ * <p>Inputs are the logits, not probabilities.
+ *
+ * @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) {
+ return SparseSoftmaxCrossEntropyWithLogits.create(scope, features, labels);
  }
 
  /**

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

@@ -354,20 +354,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 TrainOps train;
-
  public final QuantizationOps quantization;
 
+ public final TrainOps train;
+
  private final Scope scope;
 
  private Ops(Scope scope) {
@@ -385,13 +385,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);
- train = new TrainOps(this);
  quantization = new QuantizationOps(this);
+ train = new TrainOps(this);
  }
 
  /**

tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/raw/SoftmaxCrossEntropyWithLogits.java → tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SoftmaxCrossEntropyWithLogits.java

@@ -15,7 +15,7 @@
 
 // This class has been generated, DO NOT EDIT!
 
-package org.tensorflow.op.nn.raw;
+package org.tensorflow.op.nn;
 
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
@@ -34,7 +34,7 @@
  * @param <T> data type for {@code loss} output
  */
 @Operator(
- group = "nn.raw"
+ group = "nn"
 )
 public final class SoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
  /**

tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/raw/SparseSoftmaxCrossEntropyWithLogits.java → tensorflow-core/tensorflow-core-api/src/gen/java/org/tensorflow/op/nn/SparseSoftmaxCrossEntropyWithLogits.java

@@ -15,7 +15,7 @@
 
 // This class has been generated, DO NOT EDIT!
 
-package org.tensorflow.op.nn.raw;
+package org.tensorflow.op.nn;
 
 import org.tensorflow.Operand;
 import org.tensorflow.Operation;
@@ -38,7 +38,7 @@
  * @param <T> data type for {@code loss} output
  */
 @Operator(
- group = "nn.raw"
+ group = "nn"
 )
 public final class SparseSoftmaxCrossEntropyWithLogits<T extends TNumber> extends RawOp {
  /**