Add Losses

tensorflow-framework/src/main/java/org/tensorflow/framework/losses/BinaryCrossentropy.java

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. 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.framework.losses;
+
+import org.tensorflow.Operand;
+import org.tensorflow.framework.losses.impl.LossesHelper;
+import org.tensorflow.op.Ops;
+import org.tensorflow.types.family.TNumber;
+
+import static org.tensorflow.framework.utils.CastHelper.cast;
+
+/**
+ * Computes the cross-entropy loss between true labels and predicted labels.
+ *
+ * <p>Use this cross-entropy loss when there are only two label classes (assumed to be 0 and 1). For
+ * each example, there should be a single floating-point value per prediction.
+ *
+ * <p>Standalone usage:
+ *
+ * <pre>
+ *    Operand&lt;TFloat32&gt; labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand&lt;TFloat32&gt; predictions =
+ *        tf.constant(new float[][] {{0.6f, 0.4f}, {0.4f, 0.6f}});
+ *    BinaryCrossentropy bce = new BinaryCrossentropy(tf);
+ *    Operand&lt;TFloat32&gt; result = bce.call(labels, predictions);
+ *    // produces 0.815
+ * </pre>
+ *
+ * <p>Calling with sample weight:
+ *
+ * <pre>
+ *    Operand&lt;TFloat32&gt; sampleWeight = tf.constant(new float[] {1.f, 0.f});
+ *    Operand&lt;TFloat32&gt; result = bce.call(labels, predictions, sampleWeight);
+ *    // produces 0.458f
+ * </pre>
+ *
+ * <p>Using <code>SUM</code> reduction type:
+ *
+ * <pre>
+ *    BinaryCrossentropy bce = new BinaryCrossentropy(tf, Reduction.SUM);
+ *    Operand&lt;TFloat32&gt; result = bce.call(labels, predictions);
+ *    // produces 1.630f
+ * </pre>
+ *
+ * <p>Using <code>NONE</code> reduction type:
+ *
+ * <pre>
+ *    BinaryCrossentropy bce = new BinaryCrossentropy(tf, Reduction.NONE);
+ *    Operand&lt;TFloat32&gt; result = bce.call(labels, predictions);
+ *    // produces [0.916f, 0.714f]
+ * </pre>
+ */
+public class BinaryCrossentropy extends Loss {
+  public static final boolean FROM_LOGITS_DEFAULT = false;
+  public static final float LABEL_SMOOTHING_DEFAULT = 0.0f;
+
+  private final boolean fromLogits;
+  private final float labelSmoothing;
+
+  /**
+   * Creates a Binary Crossentropy Loss using {@link Class#getSimpleName()} as the loss name, {@link
+   * #FROM_LOGITS_DEFAULT} for fromLogits, {@link #LABEL_SMOOTHING_DEFAULT} for labelSmoothing and a
+   * Loss Reduction of {@link Loss#REDUCTION_DEFAULT}
+   *
+   * @param tf the TensorFlow Ops
+   */
+  public BinaryCrossentropy(Ops tf) {
+    this(tf, null, FROM_LOGITS_DEFAULT, LABEL_SMOOTHING_DEFAULT, REDUCTION_DEFAULT);
+  }
+
+  /**
+   * Creates a Binary Crossentropy loss using {@link Class#getSimpleName()} as the loss name, {@link
+   * #FROM_LOGITS_DEFAULT} for fromLogits, and {@link #LABEL_SMOOTHING_DEFAULT} for labelSmoothing
+   *
+   * @param tf the TensorFlow Ops
+   * @param reduction Type of Reduction to apply to the loss.
+   */
+  public BinaryCrossentropy(Ops tf, Reduction reduction) {
+    this(tf, null, FROM_LOGITS_DEFAULT, LABEL_SMOOTHING_DEFAULT, reduction);
+  }
+
+  /**
+   * Creates a Binary Crossentropy loss using using {@link Class#getSimpleName()} as the loss name,
+   * labelSmoothing of {@link #LABEL_SMOOTHING_DEFAULT}, a reduction of {@link
+   * Loss#REDUCTION_DEFAULT},
+   *
+   * @param tf the TensorFlow Ops
+   * @param fromLogits Whether to interpret predictions as a tensor of logit values
+   */
+  public BinaryCrossentropy(Ops tf, boolean fromLogits) {
+    this(tf, null, fromLogits, LABEL_SMOOTHING_DEFAULT, REDUCTION_DEFAULT);
+  }
+
+  /**
+   * Creates a Binary Crossentropy loss using labelSmoothing of {@link #LABEL_SMOOTHING_DEFAULT} a
+   * reduction of {@link Loss#REDUCTION_DEFAULT}.
+   *
+   * @param tf the TensorFlow Ops
+   * @param name the name of the loss
+   * @param fromLogits Whether to interpret predictions as a tensor of logit values
+   */
+  public BinaryCrossentropy(Ops tf, String name, boolean fromLogits) {
+    this(tf, name, fromLogits, LABEL_SMOOTHING_DEFAULT, REDUCTION_DEFAULT);
+  }
+
+  /**
+   * Creates a Binary Crossentropy loss using using {@link Class#getSimpleName()} as the loss name,
+   * and a reduction of {@link Loss#REDUCTION_DEFAULT}.
+   *
+   * @param tf the TensorFlow Ops
+   * @param fromLogits Whether to interpret predictions as a tensor of logit values
+   * @param labelSmoothing A number in the range, [0, 1]. When 0, no smoothing occurs. When &gt; 0,
+   *     compute the loss between the predicted labels and a smoothed version of the true labels,
+   *     where the smoothing squeezes the labels towards 0.5. Larger values of label_smoothing
+   *     correspond to heavier smoothing.
+   */
+  public BinaryCrossentropy(Ops tf, boolean fromLogits, float labelSmoothing) {
+    this(tf, null, fromLogits, labelSmoothing, REDUCTION_DEFAULT);
+  }
+
+  /**
+   * Creates a Binary Crossentropy loss using a reduction of {@link Loss#REDUCTION_DEFAULT}.
+   *
+   * @param tf the TensorFlow Ops
+   * @param name the name of the loss
+   * @param fromLogits Whether to interpret predictions as a tensor of logit values
+   * @param labelSmoothing A number in the range, [0, 1]. When 0, no smoothing occurs. When &gt; 0,
+   *     compute the loss between the predicted labels and a smoothed version of the true labels,
+   *     where the smoothing squeezes the labels towards 0.5. Larger values of label_smoothing
+   *     correspond to heavier smoothing.
+   */
+  public BinaryCrossentropy(Ops tf, String name, boolean fromLogits, float labelSmoothing) {
+    this(tf, name, fromLogits, labelSmoothing, REDUCTION_DEFAULT);
+  }
+
+  /**
+   * Creates a Binary Crossentropy loss
+   *
+   * @param tf the TensorFlow Ops
+   * @param fromLogits Whether to interpret predictions as a tensor of logit values
+   * @param labelSmoothing A number in the range, [0, 1]. When 0, no smoothing occurs. When &gt; 0,
+   *     compute the loss between the predicted labels and a smoothed version of the true labels,
+   *     where the smoothing squeezes the labels towards 0.5. Larger values of label_smoothing
+   *     correspond to heavier smoothing.
+   * @param reduction Type of Reduction to apply to the loss.
+   */
+  public BinaryCrossentropy(Ops tf, boolean fromLogits, float labelSmoothing, Reduction reduction) {
+    this(tf, null, fromLogits, labelSmoothing, reduction);
+  }
+
+  /**
+   * Creates a Binary Crossentropy loss
+   *
+   * @param tf the TensorFlow Ops
+   * @param name the name of the loss
+   * @param fromLogits Whether to interpret predictions as a tensor of logit values
+   * @param labelSmoothing A number in the range, [0, 1]. When 0, no smoothing occurs. When &gt; 0,
+   *     compute the loss between the predicted labels and a smoothed version of the true labels,
+   *     where the smoothing squeezes the labels towards 0.5. Larger values of label_smoothing
+   *     correspond to heavier smoothing.
+   * @param reduction Type of Reduction to apply to the loss.
+   * @throws IllegalArgumentException if labelSmoothing is not in the inclusive range of 0. - 1.
+   */
+  public BinaryCrossentropy(
+      Ops tf, String name, boolean fromLogits, float labelSmoothing, Reduction reduction) {
+    super(tf, name, reduction);
+    if(labelSmoothing < 0 || labelSmoothing > 1)
+      throw new IllegalArgumentException("labelSmoothing must be >= 0. and <= 1, found " + labelSmoothing);
+    this.fromLogits = fromLogits;
+    this.labelSmoothing = labelSmoothing;
+  }
+
+  /**
+   * Generates an Operand that calculates the loss.
+   *
+   * If run in Graph mode, the computation will throw {@link org.tensorflow.exceptions.TFInvalidArgumentException}
+   * if the predictions values are outside the range o [0. to 1.]. In Eager Mode, this call
+   * will throw {@link IllegalArgumentException}, if the predictions values are outside the range o [0. to 1.]
+   *
+   * @param labels the truth values or labels
+   * @param predictions the predictions, values must be in the range [0. to 1.] inclusive.
+   * @param sampleWeights Optional SampleWeights acts as a coefficient for the loss. If a scalar is
+   *     provided, then the loss is simply scaled by the given value. If SampleWeights is a tensor
+   *     of size [batch_size], then the total loss for each sample of the batch is rescaled by the
+   *     corresponding element in the SampleWeights vector. If the shape of SampleWeights is
+   *     [batch_size, d0, .. dN-1] (or can be broadcasted to this shape), then each loss element of
+   *     predictions is scaled by the corresponding value of SampleWeights. (Note on dN-1: all loss
+   *     functions reduce by 1 dimension, usually axis=-1.)
+   * @param <T> The data type of the predictions, sampleWeights and loss.
+   * @param <U> The data type of the labels.
+   * @return the loss
+   * @throws IllegalArgumentException if the predictions are outside the range [0.-1.].
+   */
+  @Override
+  public <T extends TNumber, U extends TNumber> Operand<T> call(
+      Operand<U> labels, Operand<T> predictions, Operand<T> sampleWeights) {
+    Operand<T> lPredictions;
+    if (!fromLogits) {
+      // add predictions range check for 0 - 1
+      lPredictions =
+          LossesHelper.rangeCheck(
+              getTF(),
+              "predictions range check [0-1]",
+              predictions,
+              cast(getTF(), getTF().constant(0), predictions.asOutput().dataType()),
+              cast(getTF(), getTF().constant(1), predictions.asOutput().dataType()));
+
+    } else {
+      lPredictions = predictions;
+    }
+
+    Operand<T> losses =
+        Losses.binaryCrossentropy(getTF(), labels, lPredictions, fromLogits, labelSmoothing);
+    return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights);
+  }
+}