Metrics Phase 1

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

@@ -69,7 +69,7 @@
 public class CategoricalCrossentropy extends Loss {
  public static final boolean FROM_LOGITS_DEFAULT = false;
  public static final float LABEL_SMOOTHING_DEFAULT = 0.0f;
- public static final int DEFAULT_AXIS = -1;
+ public static final int DEFAULT_AXIS = Losses.CHANNELS_LAST;
 
  private final boolean fromLogits;
  private final float labelSmoothing;
@@ -203,8 +203,9 @@ public CategoricalCrossentropy(
  * confidence on label values are relaxed. e.g. <code>labelSmoothing=0.2</code> means that we will use a
  * value of <code>0.1</code> for label <code>0</code> and <code>0.9</code> for label <code>1</code>
  * @param reduction Type of Reduction to apply to loss.
- * @param axis The channels axis. <code>axis=-1</code> corresponds to data format `Channels Last'
- * and <code>axis=1</code> corresponds to data format 'Channels First'.
+ * @param axis The channels axis. <code>axis=-1</code> corresponds to data format "Channels Last"
+ * and <code>axis=1</code> corresponds to data format "Channels First".
+ * {@link Losses#CHANNELS_LAST} and {@link Losses#CHANNELS_FIRST}
  * @throws IllegalArgumentException if labelSmoothing is not in the inclusive range of 0. - 1.
  */
  public CategoricalCrossentropy(

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

@@ -36,6 +36,9 @@ public class Losses {
  /** Default Fuzz factor. */
  public static final float EPSILON = 1e-7f;
 
+ public static final int CHANNELS_LAST = -1;
+ public static final int CHANNELS_FIRST = 1;
+
  /**
  * Calculates the mean absolute error between labels and predictions.
  *
@@ -239,7 +242,7 @@ public static <T extends TNumber, U extends TNumber> Operand<T> categoricalCross
  tLabels = smoothCategoricalLabels(tf, tLabels, labelSmoothing);
  }
  if (fromLogits) {
- return tf.nn.softmaxCrossEntropyWithLogits(tLabels, predictions, -1);
+ return tf.nn.softmaxCrossEntropyWithLogits(tLabels, predictions, axis);
  }
  /* TODO
  if (!(predictions instanceof Variable) && (!tf.scope().env().isEager())) {

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

@@ -0,0 +1,66 @@
+/* Copyright 2020 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.framework.metrics;
+
+import org.tensorflow.Operand;
+import org.tensorflow.framework.losses.Losses;
+import org.tensorflow.framework.metrics.impl.LossMetric;
+import org.tensorflow.framework.metrics.impl.MeanMetricWrapper;
+import org.tensorflow.op.Ops;
+import org.tensorflow.types.family.TNumber;
+
+/**
+ * A Metric that computes the binary cross-entropy loss between true labels and predicted labels.
+ *
+ * <p>This is the crossentropy metric class to be used when there are only two label classes (0 and
+ * 1).
+ *
+ * @param <U> the data type for the predictions.
+ * @param <T> The data type for the metric result
+ */
+public class BinaryCrossentropy<U extends TNumber, T extends TNumber>
+ extends MeanMetricWrapper<U, T> implements LossMetric<T> {
+
+ private final boolean fromLogits;
+ private final float labelSmoothing;
+
+ /**
+ * Creates a BinaryCrossentropy metric
+ *
+ * @param tf the TensorFlow Ops
+ * @param name the name of this metric, if null then metric name is {@link Class#getSimpleName()}.
+ * @param fromLogits Whether to interpret predictions as a tensor of logit values as opposed to a probability distribution.
+ * @param labelSmoothing value used to smooth labels, 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 seed the seed for random number generation. An initializer created with a given seed
+ * will always produce the same random tensor for a given shape and data type.
+ * @param type the type for the variables and result
+ */
+ public BinaryCrossentropy(
+ Ops tf, String name, boolean fromLogits, float labelSmoothing, long seed, Class<T> type) {
+ super(tf, name, seed, type);
+ setLoss(this);
+ this.fromLogits = fromLogits;
+ this.labelSmoothing = labelSmoothing;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public <V extends TNumber> Operand<T> call(Operand<V> labels, Operand<T> predictions) {
+ return Losses.binaryCrossentropy(getTF(), labels, predictions, fromLogits, labelSmoothing);
+ }
+}

tensorflow-framework/src/main/java/org/tensorflow/framework/metrics/CategoricalCrossentropy.java

@@ -0,0 +1,105 @@
+/* Copyright 2020 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.framework.metrics;
+
+import org.tensorflow.Operand;
+import org.tensorflow.framework.losses.Losses;
+import org.tensorflow.framework.metrics.impl.LossMetric;
+import org.tensorflow.framework.metrics.impl.MeanMetricWrapper;
+import org.tensorflow.op.Ops;
+import org.tensorflow.types.family.TNumber;
+
+/**
+ * A Metric that computes the categorical cross-entropy loss between true labels and predicted
+ * labels.
+ *
+ * <p>This is the crossentropy metric class to be used when there are multiple label classes (2 or
+ * more). The labels should be given as a one_hot representation. eg., When labels values are <code>
+ * [2, 0, 1]</code>, the labels Operand contains = <code>[[0, 0, 1], [1, 0, 0], [0, 1, 0]]
+ * </code>.
+ *
+ * @param <U> the data type for the predictions.
+ * @param <T> The data type for the metric result
+ */
+public class CategoricalCrossentropy<U extends TNumber, T extends TNumber>
+ extends MeanMetricWrapper<U, T> implements LossMetric<T> {
+
+ private final boolean fromLogits;
+ private final float labelSmoothing;
+ private final int axis;
+
+ /**
+ * Creates a CategoricalCrossentropy metric that computes the crossentropy metric between the
+ * labels and predictions.
+ *
+ * <p>Uses a {@link Losses#CHANNELS_LAST} for the channel axis.
+ *
+ * @param tf the TensorFlow Ops
+ * @param name the name of this metric, if null then metric name is {@link Class#getSimpleName()}.
+ * @param fromLogits Whether to interpret predictions as a tensor of logit values oras opposed to a probability distribution.
+ * @param labelSmoothing value used to smooth labels, When &gt; 0, label values are smoothed,
+ * meaning the confidence on label values are relaxed. e.g. <code>labelSmoothing=0.2</code>
+ * means that we will use a value of <code>0.1</code> for label <code>0</code> and <code>0.9
+ * </code> for label <code>1</code>
+ * @param seed the seed for random number generation. An initializer created with a given seed
+ * will always produce the same random tensor for a given shape and data type.
+ * @param type the type for the variables and result
+ */
+ public CategoricalCrossentropy(
+ Ops tf, String name, boolean fromLogits, float labelSmoothing, long seed, Class<T> type) {
+ this(tf, name, fromLogits, labelSmoothing, Losses.CHANNELS_LAST, seed, type);
+ }
+
+ /**
+ * Creates a CategoricalCrossentropy metric that computes the crossentropy metric between the
+ * labels and predictions.
+ *
+ * @param tf the TensorFlow Ops
+ * @param name the name of this metric, if null then metric name is {@link Class#getSimpleName()}.
+ * @param fromLogits Whether to interpret predictions as a tensor of logit values as opposed to a probability distribution.
+ * @param labelSmoothing value used to smooth labels, When &gt; 0, label values are smoothed,
+ * meaning the confidence on label values are relaxed. e.g. <code>labelSmoothing=0.2</code>
+ * means that we will use a value of <code>0.1</code> for label <code>0</code> and <code>0.9
+ * </code> for label <code>1</code>
+ * @param axis Int specifying the channels axis. <code>axis={@link Losses#CHANNELS_LAST}</code>
+ * corresponds to data format <code>channels_last</code>, and <code>
+ * axis={@link Losses#CHANNELS_FIRST}</code> corresponds to data format <code>
+ * channels_first</code>.
+ * @param seed the seed for random number generation. An initializer created with a given seed
+ * will always produce the same random tensor for a given shape and data type.
+ * @param type the type for the variables and result
+ */
+ public CategoricalCrossentropy(
+ Ops tf,
+ String name,
+ boolean fromLogits,
+ float labelSmoothing,
+ int axis,
+ long seed,
+ Class<T> type) {
+ super(tf, name, seed, type);
+ setLoss(this);
+ this.fromLogits = fromLogits;
+ this.labelSmoothing = labelSmoothing;
+ this.axis = axis;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public <V extends TNumber> Operand<T> call(Operand<V> labels, Operand<T> predictions) {
+ return Losses.categoricalCrossentropy(
+ getTF(), labels, predictions, fromLogits, labelSmoothing, axis);
+ }
+}

tensorflow-framework/src/main/java/org/tensorflow/framework/metrics/CategoricalHinge.java

@@ -0,0 +1,52 @@
+/* Copyright 2020 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.framework.metrics;
+
+import org.tensorflow.Operand;
+import org.tensorflow.framework.losses.Losses;
+import org.tensorflow.framework.metrics.impl.LossMetric;
+import org.tensorflow.framework.metrics.impl.MeanMetricWrapper;
+import org.tensorflow.op.Ops;
+import org.tensorflow.types.family.TNumber;
+
+/**
+ * A Metric that computes the categorical hinge loss metric between labels and predictions.
+ *
+ * @param <U> the data type for the predictions.
+ * @param <T> The data type for the metric result
+ */
+public class CategoricalHinge<U extends TNumber, T extends TNumber> extends MeanMetricWrapper<U, T>
+ implements LossMetric<T> {
+
+ /**
+ * Creates a CategoricalHinge metric
+ *
+ * @param tf the TensorFlow Ops
+ * @param name the name of this metric, if null then metric name is {@link Class#getSimpleName()}.
+ * @param seed the seed for random number generation. An initializer created with a given seed
+ * will always produce the same random tensor for a given shape and data type.
+ * @param type the type for the variables and result
+ */
+ public CategoricalHinge(Ops tf, String name, long seed, Class<T> type) {
+ super(tf, name, seed, type);
+ setLoss(this);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public <V extends TNumber> Operand<T> call(Operand<V> labels, Operand<T> predictions) {
+ return Losses.categoricalHinge(getTF(), labels, predictions);
+ }
+}

tensorflow-framework/src/main/java/org/tensorflow/framework/metrics/CosineSimilarity.java

@@ -0,0 +1,83 @@
+/* Copyright 2020 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.framework.metrics;
+
+import org.tensorflow.Operand;
+import org.tensorflow.framework.metrics.impl.LossMetric;
+import org.tensorflow.framework.metrics.impl.MeanMetricWrapper;
+import org.tensorflow.op.Ops;
+import org.tensorflow.types.family.TNumber;
+
+/**
+ * A metric that computes the cosine similarity metric between labels and predictions.
+ *
+ * @param <U> the data type for the predictions.
+ * @param <T> The data type for the metric result.
+ */
+public class CosineSimilarity<U extends TNumber, T extends TNumber> extends MeanMetricWrapper<U, T>
+ implements LossMetric<T> {
+ public static final int DEFAULT_AXIS = -1;
+ private final int[] axis;
+
+ /**
+ * Creates a metric that computes the cosine similarity metric between labels and predictions with
+ * a default axis, {@link #DEFAULT_AXIS}
+ *
+ * @param tf the TensorFlow Ops
+ * @param name the name of this metric, if null then metric name is {@link Class#getSimpleName()}.
+ * @param seed the seed for random number generation. An initializer created with a given seed
+ * will always produce the same random tensor for a given shape and data type.
+ * @param type the type for the variables and result
+ */
+ public CosineSimilarity(Ops tf, String name, long seed, Class<T> type) {
+ this(tf, name, DEFAULT_AXIS, seed, type);
+ }
+
+ /**
+ * Creates a metric that computes the cosine similarity metric between labels and predictions.
+ *
+ * @param tf the TensorFlow Ops
+ * @param name the name of this metric, if null then metric name is {@link Class#getSimpleName()}.
+ * @param axis The dimension along which the cosine similarity is computed.
+ * @param seed the seed for random number generation. An initializer created with a given seed
+ * will always produce the same random tensor for a given shape and data type.
+ * @param type the type for the variables and result
+ */
+ public CosineSimilarity(Ops tf, String name, int axis, long seed, Class<T> type) {
+ this(tf, name, new int[] {axis}, seed, type);
+ }
+ /**
+ * Creates a CosineSimilarity metric
+ *
+ * @param tf the TensorFlow Ops
+ * @param name the name of this metric, if null then metric name is {@link Class#getSimpleName()}.
+ * @param axis The dimension along which the cosine similarity is computed.
+ * @param seed the seed for random number generation. An initializer created with a given seed
+ * will always produce the same random tensor for a given shape and data type.
+ * @param type the type for the variables and result
+ */
+ public CosineSimilarity(Ops tf, String name, int[] axis, long seed, Class<T> type) {
+ super(tf, name, seed, type);
+ this.axis = axis;
+ setLoss(this);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public <V extends TNumber> Operand<T> call(Operand<V> labels, Operand<T> predictions) {
+ // NOTE: cosineProximity is a different algorithm than Losses.cosineSimilarity
+ return Metrics.cosineProximity(getTF(), labels, predictions, axis);
+ }
+}