diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/BinaryCrossentropy.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/BinaryCrossentropy.java new file mode 100644 index 00000000000..effdf990f71 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/BinaryCrossentropy.java @@ -0,0 +1,231 @@ +/* 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.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. + * + *

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. + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.6f, 0.4f}, {0.4f, 0.6f}});
+ *    BinaryCrossentropy bce = new BinaryCrossentropy(tf);
+ *    Operand<TFloat32> result = bce.call(labels, predictions);
+ *    // produces 0.815
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {1.f, 0.f});
+ *    Operand<TFloat32> result = bce.call(labels, predictions, sampleWeight);
+ *    // produces 0.458f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    BinaryCrossentropy bce = new BinaryCrossentropy(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = bce.call(labels, predictions);
+ *    // produces 1.630f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    BinaryCrossentropy bce = new BinaryCrossentropy(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = bce.call(labels, predictions);
+ *    // produces [0.916f, 0.714f]
+ *
+ */ +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 > 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 labelSmoothing + * 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 > 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 labelSmoothing + * 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 > 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 labelSmoothing + * 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 > 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 labelSmoothing + * 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 broadcast 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 The data type of the predictions, sampleWeights and loss. + * @param The data type of the labels. + * @return the loss + * @throws IllegalArgumentException if the predictions are outside the range [0.-1.]. + */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand 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 losses = + Losses.binaryCrossentropy(getTF(), labels, lPredictions, fromLogits, labelSmoothing); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CategoricalCrossentropy.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CategoricalCrossentropy.java new file mode 100644 index 00000000000..7701ebfb806 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CategoricalCrossentropy.java @@ -0,0 +1,270 @@ +/* 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.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 crossentropy loss between the labels and predictions. + * + *

Use this crossentropy loss function when there are two or more label classes. We expect labels + * to be provided in a one_hot representation. If you want to provide labels as integers, please use + * {@link SparseCategoricalCrossentropy} loss. There should be # classes floating point + * values per feature. + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0, 1, 0}, {0, 0, 1}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.05f, 0.95f, 0f}, {0.1f, 0.8f, 0.1f}});
+ *    CategoricalCrossentropy cce = new CategoricalCrossentropy(tf);
+ *    Operand<TFloat32> result = cce.call(labels, predictions);
+ *    // produces 1.177
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.3f, 0.7f});
+ *    Operand<TFloat32> result = cce.call(labels, predictions, sampleWeight);
+ *    // produces 0.814f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    CategoricalCrossentropy cce = new CategoricalCrossentropy(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = cce.call(labels, predictions);
+ *    // produces 2.354f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    CategoricalCrossentropy cce =
+ *        new CategoricalCrossentropy(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = cce.call(labels, predictions);
+ *    // produces [0.0513f, 2.303f]
+ *
+ */ +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; + + private final boolean fromLogits; + private final float labelSmoothing; + private final int axis; + + /** + * Creates a categorical cross entropy Loss using {@link Class#getSimpleName()} as the loss name, + * {@link #FROM_LOGITS_DEFAULT} for fromLogits, {@link #LABEL_SMOOTHING_DEFAULT} for + * labelSmoothing, a Loss Reduction of {@link Loss#REDUCTION_DEFAULT}, and an axis of {@link + * #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + */ + public CategoricalCrossentropy(Ops tf) { + this(tf, null, FROM_LOGITS_DEFAULT, LABEL_SMOOTHING_DEFAULT, REDUCTION_DEFAULT, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss using {@link #FROM_LOGITS_DEFAULT} for fromLogits, + * {@link #LABEL_SMOOTHING_DEFAULT} for labelSmoothing, a Loss Reduction of {@link + * Loss#REDUCTION_DEFAULT}, and an axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param name the name of this loss + */ + public CategoricalCrossentropy(Ops tf, String name) { + this(tf, name, FROM_LOGITS_DEFAULT, LABEL_SMOOTHING_DEFAULT, REDUCTION_DEFAULT, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss using {@link Class#getSimpleName()} as the loss name, + * {@link #FROM_LOGITS_DEFAULT} for fromLogits, {@link #LABEL_SMOOTHING_DEFAULT} for + * labelSmoothing and an axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to loss. + */ + public CategoricalCrossentropy(Ops tf, Reduction reduction) { + this(tf, null, FROM_LOGITS_DEFAULT, LABEL_SMOOTHING_DEFAULT, reduction, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss {@link #FROM_LOGITS_DEFAULT} for fromLogits, {@link + * #LABEL_SMOOTHING_DEFAULT} for labelSmoothing, and an axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param name the name of this loss + * @param reduction Type of Reduction to apply to loss. + */ + public CategoricalCrossentropy(Ops tf, String name, Reduction reduction) { + this(tf, name, FROM_LOGITS_DEFAULT, LABEL_SMOOTHING_DEFAULT, reduction, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss using {@link Class#getSimpleName()} as the loss name, + * {@link #LABEL_SMOOTHING_DEFAULT} for labelSmoothing, a Loss Reduction of {@link + * Loss#REDUCTION_DEFAULT}, and an axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param fromLogits Whether to interpret predictions as a tensor of logit values + */ + public CategoricalCrossentropy(Ops tf, boolean fromLogits) { + this(tf, null, fromLogits, LABEL_SMOOTHING_DEFAULT, REDUCTION_DEFAULT, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss using {@link #LABEL_SMOOTHING_DEFAULT} for + * labelSmoothing, a Loss Reduction of {@link Loss#REDUCTION_DEFAULT}, and a channel axis of + * {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param name the name of this loss + * @param fromLogits Whether to interpret predictions as a tensor of logit values + */ + public CategoricalCrossentropy(Ops tf, String name, boolean fromLogits) { + this(tf, name, fromLogits, LABEL_SMOOTHING_DEFAULT, REDUCTION_DEFAULT, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss using {@link Class#getSimpleName()} as the loss name, + * a Loss Reduction of {@link Loss#REDUCTION_DEFAULT}, and a channel axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param fromLogits Whether to interpret predictions as a tensor of logit values + * @param labelSmoothing Float in [0, 1]. When > 0, label values are smoothed, meaning the + * confidence on label values are relaxed. e.g. labelSmoothing=0.2 means that we will use a + * value of 0.1 for label 0 and 0.9 for label 1 + */ + public CategoricalCrossentropy(Ops tf, boolean fromLogits, float labelSmoothing) { + this(tf, null, fromLogits, labelSmoothing, REDUCTION_DEFAULT, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss using a Loss Reduction of {@link Loss#REDUCTION_DEFAULT}, + * and a channel axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param name the name of this loss + * @param fromLogits Whether to interpret predictions as a tensor of logit values + * @param labelSmoothing Float in [0, 1]. When > 0, label values are smoothed, meaning the + * confidence on label values are relaxed. e.g. labelSmoothing=0.2 means that we will use a + * value of 0.1 for label 0 and 0.9 for label 1 + */ + public CategoricalCrossentropy(Ops tf, String name, boolean fromLogits, float labelSmoothing) { + this(tf, name, fromLogits, labelSmoothing, REDUCTION_DEFAULT, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss using {@link Class#getSimpleName()} as the loss name + * and a channel axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param fromLogits Whether to interpret predictions as a tensor of logit values + * @param labelSmoothing Float in [0, 1]. When > 0, label values are smoothed, meaning the + * confidence on label values are relaxed. e.g. x=0.2 means that we will use a + * value of 0.1 for label 0 and 0.9 for label 1 + * @param reduction Type of Reduction to apply to loss. + */ + public CategoricalCrossentropy( + Ops tf, boolean fromLogits, float labelSmoothing, Reduction reduction) { + this(tf, null, fromLogits, labelSmoothing, reduction, DEFAULT_AXIS); + } + + /** + * Creates a categorical cross entropy Loss + * + * @param tf the TensorFlow Ops + * @param name the name of this loss + * @param fromLogits Whether to interpret predictions as a tensor of logit values + * @param labelSmoothing Float in [0, 1]. When > 0, label values are smoothed, meaning the + * confidence on label values are relaxed. e.g. labelSmoothing=0.2 means that we will use a + * value of 0.1 for label 0 and 0.9 for label 1 + * @param reduction Type of Reduction to apply to loss. + * @param axis The channels axis. axis=-1 corresponds to data format `Channels Last' + * and axis=1 corresponds to data format 'Channels First'. + * @throws IllegalArgumentException if labelSmoothing is not in the inclusive range of 0. - 1. + */ + public CategoricalCrossentropy( + Ops tf, + String name, + boolean fromLogits, + float labelSmoothing, + Reduction reduction, + int axis) { + 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; + this.axis = axis; + } + + /** + * 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 broadcast 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 The data type of the predictions, sampleWeights and loss. + * @param The data type of the labels. + * @return the loss + * @throws IllegalArgumentException if the predictions are outside the range [0.-1.]. + */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand 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 losses = + Losses.categoricalCrossentropy( + getTF(), labels, lPredictions, fromLogits, labelSmoothing, axis); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CategoricalHinge.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CategoricalHinge.java new file mode 100644 index 00000000000..f592c19f8bb --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CategoricalHinge.java @@ -0,0 +1,107 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the categorical hinge loss between labels and predictions. + * + *

loss = maximum(neg - pos + 1, 0) where neg=maximum((1-labels)*predictions) + * and pos=sum(labels*predictions) + * + *

labels values are expected to be 0 or 1.

+ * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0, 1}, {0, 0}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.6f, 0.4f}, {0.4f, 0.6f}});
+ *    CategoricalHinge categoricalHinge = new CategoricalHinge(tf);
+ *    Operand<TFloat32> result = categoricalHinge.call(labels, predictions);
+ *    // produces 1.4
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {1f, 0.f});
+ *    Operand<TFloat32> result = categoricalHinge.call(labels, predictions, sampleWeight);
+ *    // produces 0.6f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    CategoricalHinge categoricalHinge = new CategoricalHinge(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = categoricalHinge.call(labels, predictions);
+ *    // produces 2.8f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    CategoricalHinge categoricalHinge =
+ *        new CategoricalHinge(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = categoricalHinge.call(labels, predictions);
+ *    // produces [1.2f, 1.6f]
+ *
+ */ +public class CategoricalHinge extends Loss { + + /** + * Creates a Categorical Hinge Loss using {@link Class#getSimpleName()} as the loss name and a + * Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public CategoricalHinge(Ops tf) { + super(tf); + } + + /** + * Creates a Categorical Hinge Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public CategoricalHinge(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a Categorical Hinge + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public CategoricalHinge(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.categoricalHinge(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CosineSimilarity.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CosineSimilarity.java new file mode 100644 index 00000000000..137c7025c04 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/CosineSimilarity.java @@ -0,0 +1,179 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the cosine similarity between labels and predictions. + * + *

Note that it is a number between -1 and 1. When it is a negative number between -1 and 0, 0 + * indicates orthogonality and values closer to -1indicate greater similarity. The values closer to + * 1 indicate greater dissimilarity. This makes it usable as a loss function in a setting where you + * try to maximize the proximity between predictions and targets. If either labels or predictions is + * a zero vector, cosine similarity will be 0 regardless of the proximity between predictions and + * targets. + * + *

loss = -sum(l2Norm(labels) * l2Norm(predictions)) + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {1.f, 1.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{1.f, 0.f}, {1.f, 1.f}});
+ *    CosineSimilarity cosineLoss = new CosineSimilarity(tf);
+ *    Operand<TFloat32> result = cosineLoss.call(labels, predictions);
+ *    // produces -0.5
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.8f, 0.2f});
+ *    Operand<TFloat32> result = cosineLoss.call(labels, predictions, sampleWeight);
+ *    // produces -0.0999f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    CosineSimilarity cosineLoss = new CosineSimilarity(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = cosineLoss.call(labels, predictions);
+ *    // produces -0.999f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    CosineSimilarity cosineLoss = new CosineSimilarity(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = cosineLoss.call(labels, predictions);
+ *    // produces [-0.f, -0.999f]
+ *
+ */ +public class CosineSimilarity extends Loss { + public static final int DEFAULT_AXIS = -1; + public static final Reduction DEFAULT_REDUCTION = Reduction.AUTO; + + private final int axis; + + /** + * Creates a Cosine Similarity Loss using {@link Class#getSimpleName()} as the loss name, an axis + * of {@link #DEFAULT_AXIS}, and a Loss Reduction of {@link #DEFAULT_REDUCTION} + * + * @param tf the TensorFlow Ops + */ + public CosineSimilarity(Ops tf) { + + this(tf, null, DEFAULT_AXIS, DEFAULT_REDUCTION); + } + + /** + * Creates a Cosine Similarity Loss using an axis of {@link #DEFAULT_AXIS}, and a Loss Reduction + * of {@link #DEFAULT_REDUCTION} + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + */ + public CosineSimilarity(Ops tf, String name) { + + this(tf, name, DEFAULT_AXIS, DEFAULT_REDUCTION); + } + + /** + * Creates a Cosine Similarity Loss using {@link Class#getSimpleName()} as the loss name, and a + * Loss Reduction of {@link #DEFAULT_REDUCTION} + * + * @param tf the TensorFlow Ops + * @param axis The dimension along which the cosine similarity is computed. + */ + public CosineSimilarity(Ops tf, int axis) { + + this(tf, null, axis, DEFAULT_REDUCTION); + } + + /** + * Creates a Cosine Similarity Loss using a Loss Reduction of {@link #DEFAULT_REDUCTION} + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param axis The dimension along which the cosine similarity is computed. + */ + public CosineSimilarity(Ops tf, String name, int axis) { + + this(tf, name, axis, DEFAULT_REDUCTION); + } + + /** + * Creates a Cosine Similarity Loss using {@link Class#getSimpleName()} as the loss name and an + * axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public CosineSimilarity(Ops tf, Reduction reduction) { + + this(tf, null, DEFAULT_AXIS, reduction); + } + + /** + * Creates a Cosine Similarity Loss using an axis of {@link #DEFAULT_AXIS} + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public CosineSimilarity(Ops tf, String name, Reduction reduction) { + + this(tf, name, DEFAULT_AXIS, reduction); + } + + /** + * Creates a Cosine Similarity Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param axis The dimension along which the cosine similarity is computed. + * @param reduction Type of Reduction to apply to the loss. + */ + public CosineSimilarity(Ops tf, int axis, Reduction reduction) { + + this(tf, null, axis, reduction); + } + + /** + * Creates a Cosine Similarity Loss + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param axis The dimension along which the cosine similarity is computed. + * @param reduction Type of Reduction to apply to the loss. + */ + public CosineSimilarity(Ops tf, String name, int axis, Reduction reduction) { + super(tf, name, reduction); + this.axis = axis; + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.cosineSimilarity(getTF(), labels, predictions, axis); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Hinge.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Hinge.java new file mode 100644 index 00000000000..5fdfd4c9b96 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Hinge.java @@ -0,0 +1,140 @@ +/* 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.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 hinge loss between labels and predictions. + * + *

loss = maximum(1 - labels * predictions, 0)

. + * + *

labels/code> values are expected to be -1 or 1. + * If binary (0 or 1) labels are provided, they will be converted to -1 or 1.

+ * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.6f, 0.4f}, {0.4f, 0.6f}});
+ *    Hinge hingeLoss = new Hinge(tf);
+ *    Operand<TFloat32> result = hingeLoss.call(labels, predictions);
+ *    // produces 1.3f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {1.f, 0.f});
+ *    Operand<TFloat32> result = hingeLoss.call(labels, predictions, sampleWeight);
+ *    // produces 0.55f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    Hinge hingeLoss = new Hinge(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = hingeLoss.call(labels, predictions);
+ *    // produces 2.6f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    Hinge hingeLoss = new Hinge(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = hingeLoss.call(labels, predictions);
+ *    // produces [1.1f, 1.5f]
+ *
+ */ +public class Hinge extends Loss { + + /** + * Creates a Hinge Loss using {@link Class#getSimpleName()} as the loss name and a Loss Reduction + * of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public Hinge(Ops tf) { + this(tf, null, Reduction.AUTO); + } + + /** + * Creates a Hinge Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public Hinge(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a Hinge + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public Hinge(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** + * Generates an Operand that calculates the loss. + * + *

If run in Graph mode, the computation will throw {@link + * org.tensorflow.exceptions.TFInvalidArgumentException} if the label values are not in the set + * [-1., 0., 1.]. In Eager Mode, this call will throw {@link IllegalArgumentException}, if the + * label values are not in the set [-1., 0., 1.]. + * + * @param labels the truth values or labels, must be either -1, 0, or 1. Values are expected to be + * -1 or 1. If binary (0 or 1) labels are provided they will be converted to -1 or 1. + * @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 broadcast 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 The data type of the predictions, sampleWeights and loss. + * @param The data type of the labels. + * @return the loss + * @throws IllegalArgumentException if the predictions are outside the range [0.-1.]. + */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + @SuppressWarnings("unchecked") + Operand tLabels = predictions.asOutput().dataType() == labels.asOutput().dataType() ? + (Operand)labels : + cast(tf, labels, predictions.asOutput().dataType()); + tLabels = LossesHelper.valueCheck( + getTF(), + "labels value check [-1, 0, 1]", + tLabels, + cast(getTF(), getTF().constant(new int[] { -1, 0, 1}), + predictions.asOutput().dataType())); + + Operand losses = Losses.hinge(getTF(), tLabels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Huber.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Huber.java new file mode 100644 index 00000000000..6d3e3f0c2ac --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Huber.java @@ -0,0 +1,138 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the Huber loss between labels and predictions. + * + *

For each value x in error = labels - predictions: + * + * 

+ *     loss = 0.5 * x^2                  if |x| <= d
+ *     loss = 0.5 * d^2 + d * (|x| - d)  if |x| > d
+ *
+ * + *

where d is delta. + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.6f, 0.4f}, {0.4f, 0.6f}});
+ *    Huber huberLoss = new Huber(tf);
+ *    Operand<TFloat32> result = huberLoss.call(labels, predictions);
+ *    // produces 0.155
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {1.f, 0.f});
+ *    Operand<TFloat32> result = huberLoss.call(labels, predictions, sampleWeight);
+ *    // produces 0.09f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    Huber huberLoss = new Huber(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = huberLoss.call(labels, predictions);
+ *    // produces 0.32f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    Huber huberLoss = new Huber(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = huberLoss.call(labels, predictions);
+ *    // produces [0.18f, 0.13f]
+ *
+ * + * @see Huber loss + */ +public class Huber extends Loss { + public static final float DELTA_DEFAULT = 1.0f; + + private final float delta; + + /** + * Creates a Huber Loss using {@link Class#getSimpleName()} as the loss name, {@link + * #DELTA_DEFAULT} as the delta and a Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public Huber(Ops tf) { + this(tf, null, DELTA_DEFAULT, Reduction.AUTO); + } + + /** + * Creates a Huber Loss using {@link #DELTA_DEFAULT} as the delta and a Loss Reduction of {@link + * Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public Huber(Ops tf, String name) { + this(tf, name, DELTA_DEFAULT, Reduction.AUTO); + } + + /** + * Creates a Huber Loss using {@link Class#getSimpleName()} as the loss name and and {@link + * #DELTA_DEFAULT} as the delta + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public Huber(Ops tf, Reduction reduction) { + this(tf, null, DELTA_DEFAULT, reduction); + } + + /** + * Creates a Huber Loss using {@link #DELTA_DEFAULT} as the delta + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public Huber(Ops tf, String name, Reduction reduction) { + this(tf, name, DELTA_DEFAULT, reduction); + } + + /** + * Creates a Huber Loss + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param delta the point where the Huber loss function changes from quadratic to linear. + * @param reduction Type of Reduction to apply to the loss. + */ + public Huber(Ops tf, String name, float delta, Reduction reduction) { + super(tf, name, reduction); + this.delta = delta; + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.huber(getTF(), labels, predictions, delta); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/KLDivergence.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/KLDivergence.java new file mode 100644 index 00000000000..8cf3db8d518 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/KLDivergence.java @@ -0,0 +1,107 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes Kullback-Leibler divergence loss between labels and predictions. + * + *

loss = labels * log(labels / predictions) + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.6f, 0.4f}, {0.4f, 0.6f}});
+ *    KLDivergence kld = new KLDivergence(tf);
+ *    Operand<TFloat32> result = kld.call(labels, predictions);
+ *    // produces 0.458
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.8f, 0.2f});
+ *    Operand<TFloat32> result = kld.call(labels, predictions, sampleWeight);
+ *    // produces 0.366f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    KLDivergence kld = new KLDivergence(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = kld.call(labels, predictions);
+ *    // produces 0.916f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    KLDivergence kld = new KLDivergence(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = kld.call(labels, predictions);
+ *    // produces [0.916f, -3.08e-06f]
+ *
+ * + * @see Kullback?Leibler + * divergence + */ +public class KLDivergence extends Loss { + + /** + * Creates a Kullback Leibler Divergence Loss using {@link Class#getSimpleName()} as the loss name + * and a Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public KLDivergence(Ops tf) { + super(tf); + } + + /** + * Creates a Kullback Leibler Divergence Loss Loss using {@link Class#getSimpleName()} as the loss + * name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public KLDivergence(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a Kullback Leibler Divergence Loss + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public KLDivergence(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.kullbackLeiblerDivergence(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/LogCosh.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/LogCosh.java new file mode 100644 index 00000000000..1669669a768 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/LogCosh.java @@ -0,0 +1,113 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes Computes the logarithm of the hyperbolic cosine of the prediction error. + * + *

logcosh = log((exp(x) + exp(-x))/2), where x is the error + * predictions - labels. + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{1.f, 1.f}, {0.f, 0.f}});
+ *    LogCosh logcosh = new LogCosh(tf);
+ *    Operand<TFloat32> result = logcosh.call(labels, predictions);
+ *    // produces 0.108
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.8f, 0.2f});
+ *    Operand<TFloat32> result = logcosh.call(labels, predictions, sampleWeight);
+ *    // produces 0.087f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    LogCosh logcosh = new LogCosh(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = logcosh.call(labels, predictions);
+ *    // produces 0.217f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    LogCosh logcosh = new LogCosh(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = logcosh.call(labels, predictions);
+ *    // produces [0.217f, 0f]
+ *
+ */ +public class LogCosh extends Loss { + + /** + * Creates a LogCosh Loss using {@link Class#getSimpleName()} as the loss name and a Loss + * Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public LogCosh(Ops tf) { + this(tf, null, Reduction.AUTO); + } + + /** + * Creates a LogCosh Loss using a Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public LogCosh(Ops tf, String name) { + this(tf, name, Reduction.AUTO); + } + + /** + * Creates a LogCosh Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public LogCosh(Ops tf, Reduction reduction) { + this(tf, null, reduction); + } + + /** + * Creates a LogCosh Loss + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public LogCosh(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.logCosh(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Loss.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Loss.java new file mode 100644 index 00000000000..ae33d5dfa37 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Loss.java @@ -0,0 +1,108 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +public abstract class Loss { + public static final Reduction REDUCTION_DEFAULT = Reduction.AUTO; + + protected final Ops tf; + protected final Reduction reduction; + + /** + * Creates a Loss using {@link Class#getSimpleName()} as the name and a Loss Reduction of {@link + * Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + protected Loss(Ops tf) { + this(tf, null, Reduction.AUTO); + } + + /** + * Creates a Loss using a Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + * @param name the name of this Loss, if null the name will be {@link Class#getSimpleName()}. + */ + protected Loss(Ops tf, String name) { + this(tf, name, Reduction.AUTO); + } + + /** + * Creates a Loss + * + * @param tf the TensorFlow Ops + * @param name the name of this loss, if null the name will be {@link Class#getSimpleName()}. + * @param reduction Type of Reduction to apply to the loss. + */ + protected Loss(Ops tf, String name, Reduction reduction) { + this.tf = name != null ? tf.withSubScope(name) : tf.withSubScope(getClass().getSimpleName()); + this.reduction = reduction; + } + + /** + * Calculates the loss + * + * @param labels the truth values or labels + * @param predictions the predictions + * @param The data type of the predictions and loss. + * @param The data type of the labels. + * @return the loss + */ + public Operand call(Operand labels, Operand predictions) { + return call(labels, predictions, null); + } + + /** + * Generates an Operand that calculates the loss. + * + * @param labels the truth values or labels + * @param predictions the predictions + * @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 broadcast 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 The data type of the predictions, sampleWeights and loss. + * @param The data type of the labels. + * @return the loss + */ + public abstract Operand call( + Operand labels, Operand predictions, Operand sampleWeights); + + /** + * Gets the TensorFlow Ops + * + * @return the TensorFlow Ops + */ + public Ops getTF() { + return tf; + } + + /** + * Gets the loss reduction + * + * @return the loss reduction + */ + public Reduction getReduction() { + return reduction; + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Losses.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Losses.java new file mode 100644 index 00000000000..7a633ede2bf --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Losses.java @@ -0,0 +1,704 @@ +/* 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.losses; + +import org.tensorflow.DataType; +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossTuple; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.op.core.ReduceAll; +import org.tensorflow.op.core.ReduceMax; +import org.tensorflow.op.core.ReduceSum; +import org.tensorflow.op.math.Mean; +import org.tensorflow.op.math.Softplus; +import org.tensorflow.types.TBool; +import org.tensorflow.types.TInt64; +import org.tensorflow.types.family.TNumber; + +import static org.tensorflow.framework.utils.CastHelper.cast; + +/** Built-in loss functions. */ +public class Losses { + + /** Default Fuzz factor. */ + public static final float EPSILON = 1e-7f; + + /** + * Calculates the mean absolute error between labels and predictions. + * + *

loss = reduceMean(abs(labels - predictions)) + * + * @param tf The TensorFlow Ops + * @param labels the labels + * @param predictions the predictions + * @param the data type of the predictions and result + * @param the data type of the labels + * @return the mean absolute error + */ + public static Operand meanAbsoluteError( + Ops tf, Operand labels, Operand predictions) { + Operand tLabels = cast(tf, labels, predictions.asOutput().dataType()); + LossTuple ops = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = ops.getTarget(); + tLabels = ops.getLabels(); + return tf.math.mean( + tf.math.abs(tf.math.sub(tLabels, predictions)), tf.constant(-1), Mean.keepDims(false)); + } + + /** + * Computes the mean squared error between labels and predictions. + * + *

loss = reduceMean(square(labels - predictions)) + * + * @param tf The TensorFlow Ops + * @param labels the labels + * @param predictions the predictions + * @param the data type of the predictions and result + * @param the data type of the labels + * @return the mean squared error + */ + public static Operand meanSquaredError( + Ops tf, Operand labels, Operand predictions) { + Operand tLabels = cast(tf, labels, predictions.asOutput().dataType()); + LossTuple ops = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = ops.getTarget(); + tLabels = ops.getLabels(); + return tf.math.mean(tf.math.squaredDifference(predictions, tLabels), tf.constant(-1)); + } + + /** + * Calculates the mean absolute percentage error between labels and predictions. + * + *

loss = 100 * reduceMean(abs((labels - predictions) / labels)) + * + * @param tf The TensorFlow Ops + * @param labels the labels + * @param predictions the predictions + * @param the data type of the predictions and result + * @param the data type of the labels + * @return the mean absolute percentage error + */ + public static Operand meanAbsolutePercentageError( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple ops = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = ops.getTarget(); + tLabels = ops.getLabels(); + Operand diff = + tf.math.abs( + tf.math.div( + tf.math.sub(tLabels, predictions), + tf.math.maximum(tf.math.abs(tLabels), cast(tf, tf.constant(EPSILON), dataType)))); + return tf.math.mul(cast(tf, tf.constant(100), dataType), tf.math.mean(diff, tf.constant(-1))); + } + + /** + * Calculates the mean squared logarithmic error between labels and predictions. + * + *

loss = reduceMean(square(log(labels + 1) - log(predictions + 1))) + * + * @param tf The TensorFlow Ops + * @param labels the labels + * @param predictions the predictions + * @param the data type of the predictions and result + * @param the data type of the labels + * @return the mean squared logarithmic percentage error + */ + public static Operand meanSquaredLogarithmicError( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple ops = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = ops.getTarget(); + tLabels = ops.getLabels(); + + Operand epsilonConst = cast(tf, tf.constant(EPSILON), dataType); + Operand one = cast(tf, tf.constant(1), dataType); + + Operand firstLog = tf.math.log(tf.math.add(tf.math.maximum(predictions, epsilonConst), one)); + Operand secondLog = tf.math.log(tf.math.add(tf.math.maximum(tLabels, epsilonConst), one)); + + return tf.math.mean(tf.math.squaredDifference(firstLog, secondLog), tf.constant(-1)); + } + + /** + * Computes the binary crossentropy loss between labels and predictions. + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @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 > 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 labelSmoothing + * correspond to heavier smoothing. + * @param the data type of the predictions and labels + * @return the binary crossentropy loss. + */ + public static Operand binaryCrossentropy( + Ops tf, Operand labels, Operand predictions, boolean fromLogits, float labelSmoothing) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple ops = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = ops.getTarget(); + tLabels = ops.getLabels(); + + if (labelSmoothing != 0.0f) { + tLabels = smoothBinaryLabels(tf, tLabels, labelSmoothing); + } + Operand bce = binaryCrossentropyHelper(tf, tLabels, predictions, fromLogits); + return tf.math.mean(bce, tf.constant(-1)); + } + + /** + * Computes the unreduced crossentropy loss between labels and predictions. + * + * @param tf the TensorFlow Ops + * @param target the target Operand + * @param output the output, either logits or a probability distribution + * @param fromLogits whether `output` is expected to be a logits tensor. By default, we consider + * that `output` encodes a probability distribution. + * @param the data type of the Operands + * @return the binary crossentropy loss. + */ + private static Operand binaryCrossentropyHelper( + Ops tf, Operand target, Operand output, boolean fromLogits) { + if (fromLogits) return tf.nn.sigmoidCrossEntropyWithLogits(target, output); + + /* TODO - skip this loggic for now. It requires walking back the inputs which is not yet possible + if (!(output instanceof Variable) && (!tf.scope().env().isEager())) { + // TODO - this does not work + // TODO output = backtrackIdentity(output); + // TODO if (output.op().type().equals(Sigmoid.OP_NAME)) { + // TODO if (output.op().numInputess() != 1) + // TODO throw new IllegalArgumentException("output can only have 1 output"); + // TODO output = output.op().inout(0); + // TODO return tf.nn.sigmoidCrossEntropyWithLogits(target, output); + // TODO} + } + */ + + DataType dataType = output.asOutput().dataType(); + Operand one = cast(tf, tf.constant(1), dataType); + Operand epsilonConst = cast(tf, tf.constant(EPSILON), dataType); + Operand oneMinusEpsilonConst = tf.math.sub(one, epsilonConst); + output = tf.clipByValue(output, epsilonConst, oneMinusEpsilonConst); + + // Compute cross entropy from probabilities. + Operand bce = tf.math.mul(target, tf.math.log(tf.math.add(output, epsilonConst))); + bce = + tf.math.add( + bce, + tf.math.mul( + tf.math.sub(one, target), + tf.math.log(tf.math.add(tf.math.sub(one, output), epsilonConst)))); + return tf.math.neg(bce); + } + + /** + * Computes the categorical crossentropy loss between labels and predictions. + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @param fromLogits Whether to interpret predictions as a tensor of logit values + * @param labelSmoothing Float in [0, 1]. When > 0, label values are smoothed, meaning the + * confidence on label values are relaxed. e.g. labelSmoothing=0.2 means that we will use a + * value of 0.1 for label 0 and 0.9 for label 1 + * @param axis the + * @param the data type of the predictions and labels + * @return the categorical crossentropy loss. + */ + public static Operand categoricalCrossentropy( + Ops tf, + Operand labels, + Operand predictions, + boolean fromLogits, + float labelSmoothing, + int axis) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple ops = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = ops.getTarget(); + tLabels = ops.getLabels(); + + if (labelSmoothing != 0.0f) { + tLabels = smoothCategoricalLabels(tf, tLabels, labelSmoothing); + } + if (fromLogits) { + return tf.nn.softmaxCrossEntropyWithLogits(tLabels, predictions, -1); + } + /* TODO + if (!(predictions instanceof Variable) && (!tf.scope().env().isEager())) { + + // TODO output = backtrackIdentity(output); doesn't seem to work with Java version. + if (predictions.op().type().equals("Softmax")) { + if (predictions.op().numOutputs() != 1) + throw new IllegalArgumentException("output can only have 1 output"); + predictions = predictions.op().output(0); + return tf.nn.softmaxCrossEntropyWithLogits(tLabels, predictions, -1); + } + } + */ + + Operand one = cast(tf, tf.constant(1), dataType); + Operand epsilonConst = cast(tf, tf.constant(EPSILON), dataType); + Operand oneMinusEpsilonConst = tf.math.sub(one, epsilonConst); + predictions = + tf.math.div( + predictions, tf.reduceSum(predictions, tf.constant(axis), ReduceSum.keepDims(true))); + predictions = tf.clipByValue(predictions, epsilonConst, oneMinusEpsilonConst); + + // Compute cross entropy from probabilities. + Operand cce = + tf.reduceSum( + tf.math.mul(tLabels, tf.math.log(predictions)), + tf.constant(axis), + ReduceSum.keepDims(false)); + return tf.math.neg(cce); + } + + /** + * Computes the categorical hinge loss between labels and predictions. + * + * @param tf the TensorFlow Ops + * @param labels true targets, values are expected to be 0 or 1. + * @param predictions the predictions + * @param the data type of the predictions and labels + * @return the categorical hinge loss + */ + public static Operand categoricalHinge( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + Operand one = cast(tf, tf.constant(1), dataType); + Operand zero = cast(tf, tf.constant(0), dataType); + + Operand pos = + tf.reduceSum( + tf.math.mul(tLabels, predictions), tf.constant(-1), ReduceSum.keepDims(Boolean.FALSE)); + Operand neg = + tf.reduceMax( + tf.math.mul(tf.math.sub(one, tLabels), predictions), + tf.constant(-1), + ReduceMax.keepDims(Boolean.FALSE)); + Operand sub = tf.math.sub(neg, pos); + Operand add = tf.math.add(sub, one); + return tf.math.maximum(zero, add); + } + + /** + * Computes the cosine similarity loss between labels and predictions. + * + *

Note that it is a number between -1 and 1, which is different from + * the mathematical definition of cosine similarity where 1 represents similar + * vectors, and 0 represents dissimilar vectors. In this function, the numbers are + * inverted in a range of -1 to 1. When it is a negative number between + * -1 and 0, 0 indicates orthogonality and values closer to + * -1 indicate greater similarity. The values closer to 1 indicate + * greater dissimilarity. This makes it usable as a loss function in a setting where you try to + * maximize the proximity between predictions and targets. If either labels or predictions is a + * zero vector, cosine similarity will be 0 regardless of the proximity between + * predictions and targets. + * + *

loss = -sum(l2Norm(labels) * l2Norm(predictions)) + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @param axis Axis along which to determine similarity. + * @param the data type of the predictions and labels + * @return the cosine similarity loss + */ + public static Operand cosineSimilarity( + Ops tf, Operand labels, Operand predictions, int axis) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + + tLabels = l2Normalize(tf, tLabels, axis); + predictions = l2Normalize(tf, predictions, axis); + Operand mathMul = tf.math.mul(tLabels, predictions); + Operand sum = tf.reduceSum(mathMul, tf.constant(axis), ReduceSum.keepDims(Boolean.FALSE)); + return tf.math.neg(sum); + } + + /** + * Computes the hinge loss between labels and predictions + * + *

loss = reduceMean(maximum(1 - labels * predictions, 0)) + * + * @param tf the TensorFlow Ops + * @param labels true targets, values are expected to be -1 or 1. If binary (0 or 1) labels are + * provided, they will be converted to -1 or 1. + * @param predictions the predictions + * @param the data type of the predictions and labels + * @return the hinge loss + */ + public static Operand hinge( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + Operand one = cast(tf, tf.constant(1), dataType); + Operand zero = cast(tf, tf.constant(0), dataType); + + tLabels = maybeConvertLabels(tf, tLabels); + + return tf.math.mean( + tf.math.maximum(tf.math.sub(one, tf.math.mul(tLabels, predictions)), zero), + tf.constant(-1)); + } + + /** + * Computes the Huber loss between labels and predictions. + * + *

For each value x in error = labels - predictions: + * + * 

+   *     loss = 0.5 * x^2                  if |x| <= d
+   *     loss = 0.5 * d^2 + d * (|x| - d)  if |x| > d
+   *
+ * + *

where d is delta. + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @param delta the point where the Huber loss function changes from quadratic to linear. + * @param the data type of the predictions and labels + * @return the Huber loss + */ + public static Operand huber( + Ops tf, Operand labels, Operand predictions, float delta) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + + Operand error = tf.math.sub(predictions, tLabels); + Operand deltaConst = cast(tf, tf.constant(delta), dataType); + Operand point5 = cast(tf, tf.constant(0.5), dataType); + Operand absError = tf.math.abs(error); + Operand quadratic = tf.math.minimum(absError, deltaConst); + Operand linear = tf.math.sub(absError, quadratic); + Operand q2Point5 = tf.math.mul(point5, tf.math.mul(quadratic, quadratic)); + Operand deltaLinear = tf.math.mul(deltaConst, linear); + Operand loss = tf.math.add(q2Point5, deltaLinear); + return tf.math.mean(loss, tf.constant(-1)); + } + + /** + * Computes the Kullback-Leibler divergence loss between labels and predictions. + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @param the data type of the predictions and labels + * @return the Kullback-Leibler divergence loss + * @see Kullback?Leibler + * divergence + */ + public static Operand kullbackLeiblerDivergence( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + Operand one = cast(tf, tf.constant(1), dataType); + Operand epsilonConst = cast(tf, tf.constant(EPSILON), dataType); + + tLabels = tf.clipByValue(tLabels, epsilonConst, one); + predictions = tf.clipByValue(predictions, epsilonConst, one); + return tf.reduceSum( + tf.math.mul(tLabels, tf.math.log(tf.math.div(tLabels, predictions))), tf.constant(-1)); + } + + /** + * Computes the hyperbolic cosine loss between labels and predictions. + * + *

log(cosh(x)) is approximately equal to (x ** 2) / 2 for small + * x and to abs(x) - log(2) for large x. This means that + * 'logCosh' works mostly like the mean squared error, but will not be so strongly affected by the + * occasional wildly incorrect prediction. + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @param the data type of the predictions and labels + * @return the hyperbolic cosine divergence loss + */ + public static Operand logCosh( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + Operand minusTwo = cast(tf, tf.constant(-2), dataType); + Operand two = cast(tf, tf.constant(2), dataType); + + Operand diff = tf.math.sub(predictions, tLabels); + Softplus softplus = tf.math.softplus(tf.math.mul(minusTwo, diff)); + Operand logcosh = tf.math.sub(tf.math.add(diff, softplus), tf.math.log(two)); + return tf.math.mean(logcosh, tf.constant(-1)); + } + + /** + * Computes the Poisson loss between labels and predictions. + * + *

The Poisson loss is the mean of the elements of the Tensor + * predictions - labels * log(predictions). + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @param the data type of the predictions and labels + * @return the Poisson loss + */ + public static Operand poisson( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + Operand epsilonConst = cast(tf, tf.constant(EPSILON), dataType); + + return tf.math.mean( + tf.math.sub( + predictions, tf.math.mul(tLabels, tf.math.log(tf.math.add(predictions, epsilonConst)))), + tf.constant(-1)); + } + + /** + * Computes the sparse categorical crossentropy loss between labels and predictions. + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param predictions the predictions + * @param fromLogits Whether predictions is expected to be logits. By default, it is assumed that + * predictions encodes a probability distribution. + * @param axis The dimension along which the entropy is computed. + * @param the data type of the predictions and labels + * @return the sparse categorical crossentropy loss + */ + public static Operand sparseCategoricalCrossentropy( + Ops tf, Operand labels, Operand predictions, boolean fromLogits, int axis) { + DataType dataType = predictions.asOutput().dataType(); + Operand epsilonConst = cast(tf, tf.constant(EPSILON), dataType); + Operand one = cast(tf, tf.constant(1), dataType); + Operand oneMinusEpsilonConst = tf.math.sub(one, epsilonConst); + + /* TODO need ability to walk back inputs + if (!fromLogits && !(predictions instanceof Variable) && (!tf.scope().env().isEager())) { + // TODO output = backtrackIdentity(output); doesn't seem to work with Java version. + /* TODO + if (predictions.op().type().equals(Softmax.OP_NAME)) { + // When softmax activation function is used for output operation, we + // use logits from the softmax function directly to compute loss in order + // to prevent collapsing zero when training. + // TODO if( output.op().numOutputs() != 1) + // throw new IllegalArgumentException("output can only have 1 output"); + // TODO output = output.op.inputs[0] + fromLogits = true; + } + + } + */ + if (!fromLogits) { + + predictions = tf.clipByValue(predictions, epsilonConst, oneMinusEpsilonConst); + predictions = tf.math.log(predictions); + } + Shape predictionsShape = predictions.asOutput().shape(); + int predictionsRank = predictionsShape.numDimensions(); + axis %= predictionsRank; + if (axis < 0) { + axis += predictionsRank; + } + if (axis != predictionsRank - 1) { + int[] axisNew = moveAxisToEnd(axis, predictionsRank); + predictions = tf.linalg.transpose(predictions, tf.constant(axisNew)); + } + + Operand iLabels = cast(tf, labels, TInt64.DTYPE); + + // Try to adjust the shape so that rank of labels = rank of logits - 1. + Shape labelsShape = labels.asOutput().shape(); + int labelsRank = labelsShape.numDimensions(); + + boolean updateShape = labelsRank != predictionsRank - 1; + if (updateShape) { // TODO check to see if this is right + Shape newShape = labelsShape.take(labelsRank - 1); + iLabels = tf.reshape(iLabels, tf.constant(newShape)); // flatten one dimension + predictions = + tf.reshape( + predictions, + tf.constant( + new long[] {-1L, predictionsShape.size(predictionsShape.numDimensions() - 1)})); + } + + @SuppressWarnings("unchecked") + Operand loss = tf.nn.sparseSoftmaxCrossEntropyWithLogits(iLabels, predictions); + if (updateShape && predictionsRank >= 3) { + Shape newShape = predictionsShape.take(predictionsShape.numDimensions() - 1); + loss = tf.reshape(loss, tf.constant(newShape)); + } + return loss; + } + + /** + * Computes the squared hinge loss between labels and predictions. + * + *

loss = reduceMean(square(maximum(1 - labels * predictions, 0))) + * + * @param tf the TensorFlow Ops + * @param labels true targets, values are expected to be -1 or 1. If binary (0 or 1) labels are * + * provided, they will be converted to -1 or 1. + * @param predictions the predictions + * @param the data type of the predictions and labels + * @return the squared hinge loss + */ + public static Operand squaredHinge( + Ops tf, Operand labels, Operand predictions) { + DataType dataType = predictions.asOutput().dataType(); + Operand tLabels = cast(tf, labels, dataType); + LossTuple lossTuple = LossesHelper.squeezeOrExpandDimensions(tf, tLabels, predictions, null); + predictions = lossTuple.getTarget(); + tLabels = lossTuple.getLabels(); + Operand one = cast(tf, tf.constant(1), dataType); + Operand zero = cast(tf, tf.constant(0), dataType); + + tLabels = maybeConvertLabels(tf, tLabels); + return tf.math.mean( + tf.math.square(tf.math.maximum(tf.math.sub(one, tf.math.mul(tLabels, predictions)), zero)), + tf.constant(-1)); + } + + /** + * Smooths binary labels + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param labelSmoothing A number in the range [0, 1]. When 0, no smoothing occurs. When > 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 labelSmoothing + * correspond to heavier smoothing. + * @param the data type of the labels + * @return the smoothed binary labels + */ + private static Operand smoothBinaryLabels( + Ops tf, Operand labels, float labelSmoothing) { + DataType dataType = labels.asOutput().dataType(); + Operand oneMinusSmoothing = cast(tf, tf.constant(1.f - labelSmoothing), dataType); + Operand halfSmoothing = cast(tf, tf.constant(0.5F * labelSmoothing), dataType); + return tf.math.add(tf.math.mul(labels, oneMinusSmoothing), halfSmoothing); + } + + /** + * Smooths categorical labels + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param labelSmoothing Float in [0, 1]. When > 0, label values are smoothed, meaning the + * confidence on label values are relaxed. e.g. labelSmoothing=0.2 means that we will use a + * value of 0.1 for label 0 and 0.9 for label 1 + * @param the data type of the labels + * @return the smoothed categorical labels + */ + private static Operand smoothCategoricalLabels( + Ops tf, Operand labels, float labelSmoothing) { + DataType dataType = labels.asOutput().dataType(); + Operand smoothing = cast(tf, tf.constant(labelSmoothing), dataType); + Shape labelsShape = labels.asOutput().shape(); + int numDims = labelsShape.numDimensions(); + Operand numClasses = cast(tf, tf.constant(labelsShape.size(numDims - 1)), dataType); + Operand oneMinusSmoothing = cast(tf, tf.constant(1.f - labelSmoothing), dataType); + return tf.math.add(tf.math.mul(labels, oneMinusSmoothing), tf.math.div(smoothing, numClasses)); + } + + // TODO this was tf.math.l2_normalize in TF Python + /** + * Normalizes along dimension axis using an L2 norm. + * + * @param tf The TensorFlow Ops + * @param x the input + * @param axis Dimension along which to normalize. + * @return the normalized values based on L2 norm + */ + public static Operand l2Normalize(Ops tf, Operand x, int axis) { + Operand squareSum = + tf.reduceSum(tf.math.square(x), tf.constant(axis), ReduceSum.keepDims(Boolean.TRUE)); + Operand invNorm = + tf.math.rsqrt( + tf.math.maximum(squareSum, cast(tf, tf.constant(1e-12F), x.asOutput().dataType()))); + return tf.math.mul(x, invNorm); + } + + /** + * Converts binary labels into -1/1. + * + * @param tf the TensorFlow Ops + * @param labels true targets + * @param the data type of the labels + * @return the labels, possibly converted into -1/1. + */ + private static Operand maybeConvertLabels(Ops tf, Operand labels) { + DataType dataType = labels.asOutput().dataType(); + + Operand one = cast(tf, tf.constant(1), dataType); + Operand zero = cast(tf, tf.constant(0), dataType); + Operand two = cast(tf, tf.constant(2), dataType); + Operand areZeros = tf.math.equal(labels, zero); + Operand areOnes = tf.math.equal(labels, one); + Operand isBinary = + tf.reduceAll( + tf.math.logicalOr(areZeros, areOnes), tf.constant(-1), ReduceAll.keepDims(true)); + Operand convertBinaryLabels = tf.math.sub(tf.math.mul(two, labels), one); + return tf.select(isBinary, convertBinaryLabels, labels); + } + + /** + * Move the specified axis to end, to be used with transposes + * + * @param axis the axis to move + * @param outputRank the rank of the shape + * @return the new dimension array with the axis moved to the end. + */ + private static int[] moveAxisToEnd(int axis, int outputRank) { + int[] axisNew = new int[outputRank]; + for (int i = 0; i < axis; i++) { + axisNew[i] = i; + } + for (int i = axis + 1; i < outputRank; i++) { + axisNew[i - 1] = i; + } + axisNew[outputRank - 1] = axis; + return axisNew; + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanAbsoluteError.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanAbsoluteError.java new file mode 100644 index 00000000000..a2d5d5f8efc --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanAbsoluteError.java @@ -0,0 +1,103 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the mean of absolute difference between labels and predictions. + * + *

loss = abs(labels - predictions) + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{1.f, 1.f}, {1.f, 0.f}});
+ *    MeanAbsoluteError mae = new MeanAbsoluteError(tf);
+ *    Operand<TFloat32> result = mae.call(labels, predictions);
+ *    // produces 0.5f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.7f, 0.3f});
+ *    Operand<TFloat32> result = mae.call(labels, predictions, sampleWeight);
+ *    // produces 0.25f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    MeanAbsoluteError mae = new MeanAbsoluteError(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = mae.call(labels, predictions);
+ *    // produces 1.0f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    MeanAbsoluteError mae = new MeanAbsoluteError(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = mae.call(labels, predictions);
+ *    // produces [0.5f, 0.5f]
+ *
+ */ +public class MeanAbsoluteError extends Loss { + + /** + * Creates a MeanAbsoluteError Loss using {@link Class#getSimpleName()} as the loss name and a + * Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public MeanAbsoluteError(Ops tf) { + super(tf); + } + + /** + * Creates a MeanAbsoluteError Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanAbsoluteError(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a MeanAbsoluteError + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanAbsoluteError(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.meanAbsoluteError(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanAbsolutePercentageError.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanAbsolutePercentageError.java new file mode 100644 index 00000000000..49133df610b --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanAbsolutePercentageError.java @@ -0,0 +1,103 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the mean absolute percentage error between labels and predictions. + * + *

loss = 100 * abs(labels - predictions) / labels + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{2.f, 1.f}, {2.f, 3.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{1.f, 1.f}, {1.f, 0.f}});
+ *    MeanAbsolutePercentageError mape = new MeanAbsolutePercentageError(tf);
+ *    Operand<TFloat32> result = mape.call(labels, predictions);
+ *    // produces 50f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.7f, 0.3f});
+ *    Operand<TFloat32> result = mape.call(labels, predictions, sampleWeight);
+ *    // produces 20f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    MeanAbsolutePercentageError mape = new MeanAbsolutePercentageError(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = mape.call(labels, predictions);
+ *    // produces 100.0f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    MeanAbsolutePercentageError mape = new MeanAbsolutePercentageError(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = mape.call(labels, predictions);
+ *    // produces [25f, 75f]
+ *
+ */ +public class MeanAbsolutePercentageError extends Loss { + + /** + * Creates a MeanAbsolutePercentageError Loss using {@link Class#getSimpleName()} as the loss name + * and a Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public MeanAbsolutePercentageError(Ops tf) { + super(tf); + } + + /** + * Creates a MeanAbsolutePercentageError Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanAbsolutePercentageError(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a MeanAbsolutePercentageError + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanAbsolutePercentageError(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.meanAbsolutePercentageError(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanSquaredError.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanSquaredError.java new file mode 100644 index 00000000000..2a6c2be885e --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanSquaredError.java @@ -0,0 +1,103 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the mean of squares of errors between labels and predictions. + * + *

loss = loss = square(labels - predictions) + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{1.f, 1.f}, {1.f, 0.f}});
+ *    MeanSquaredError mse = new MeanSquaredError(tf);
+ *    Operand<TFloat32> result = mse.call(labels, predictions);
+ *    // produces 0.5f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.7f, 0.3f});
+ *    Operand<TFloat32> result = mse.call(labels, predictions, sampleWeight);
+ *    // produces 0.25f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    MeanSquaredError mse = new MeanSquaredError(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = mse.call(labels, predictions);
+ *    // produces 1.0f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    MeanSquaredError mse = new MeanSquaredError(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = mse.call(labels, predictions);
+ *    // produces [0.5f, 0.5f]
+ *
+ */ +public class MeanSquaredError extends Loss { + + /** + * Creates a MeanSquaredError Loss using {@link Class#getSimpleName()} as the loss name and a Loss + * Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public MeanSquaredError(Ops tf) { + super(tf); + } + + /** + * Creates a MeanSquaredError Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanSquaredError(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a MeanSquaredError + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanSquaredError(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.meanSquaredError(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanSquaredLogarithmicError.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanSquaredLogarithmicError.java new file mode 100644 index 00000000000..2604e226b81 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/MeanSquaredLogarithmicError.java @@ -0,0 +1,103 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the mean squared logarithmic errors between labels and predictions. + * + *

loss = square(log(labels + 1.) - log(predictions + 1.)) + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{1.f, 1.f}, {1.f, 0.f}});
+ *    MeanSquaredLogarithmicError msle = new MeanSquaredLogarithmicError(tf);
+ *    Operand<TFloat32> result = msle.call(labels, predictions);
+ *    // produces 0.240f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.7f, 0.3f});
+ *    Operand<TFloat32> result = msle.call(labels, predictions, sampleWeight);
+ *    // produces 0.120f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    MeanSquaredLogarithmicError msle = new MeanSquaredLogarithmicError(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = msle.call(labels, predictions);
+ *    // produces 0.480f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    MeanSquaredLogarithmicError msle = new MeanSquaredLogarithmicError(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = msle.call(labels, predictions);
+ *    // produces [0.240f, 0.240f]
+ *
+ */ +public class MeanSquaredLogarithmicError extends Loss { + + /** + * Creates a MeanSquaredError Loss using {@link Class#getSimpleName()} as the loss name and a Loss + * Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public MeanSquaredLogarithmicError(Ops tf) { + super(tf); + } + + /** + * Creates a MeanSquaredError Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanSquaredLogarithmicError(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a MeanSquaredError + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public MeanSquaredLogarithmicError(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.meanSquaredLogarithmicError(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Poisson.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Poisson.java new file mode 100644 index 00000000000..c43be4f2821 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Poisson.java @@ -0,0 +1,112 @@ +/* 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.losses; + +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.impl.LossesHelper; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TNumber; + +/** + * Computes the Poisson loss between labels and predictions. + * + *

loss = predictions - labels * log(predictions) + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0.f, 1.f}, {0.f, 0.f}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{1.f, 1.f}, {0.f, 0.f}});
+ *    Poisson poissonLoss = new Poisson(tf);
+ *    Operand<TFloat32> result = poissonLoss.call(labels, predictions);
+ *    // produces 0.5f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.8f, 0.2f});
+ *    Operand<TFloat32> result = poissonLoss.call(labels, predictions, sampleWeight);
+ *    // produces 0.4f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    Poisson poissonLoss = new Poisson(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = poissonLoss.call(labels, predictions);
+ *    // produces 0.999f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    Poisson poissonLoss = new Poisson(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = poissonLoss.call(labels, predictions);
+ *    // produces [0.999f, 0f]
+ *
+ */ +public class Poisson extends Loss { + + /** + * Creates a Poisson Loss using {@link Class#getSimpleName()} as the loss name and a Loss + * Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public Poisson(Ops tf) { + this(tf, null, Reduction.AUTO); + } + + /** + * Creates a Poisson Loss using a Loss Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public Poisson(Ops tf, String name) { + this(tf, name, Reduction.AUTO); + } + + /** + * Creates a Poisson Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public Poisson(Ops tf, Reduction reduction) { + this(tf, null, reduction); + } + + /** + * Creates a Poisson Loss + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public Poisson(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** {@inheritDoc} */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand losses = Losses.poisson(getTF(), labels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Reduction.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Reduction.java new file mode 100644 index 00000000000..87ea43c6c3a --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/Reduction.java @@ -0,0 +1,45 @@ +/* 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.losses; + +/** + * Type of Loss Reduction + * + *

{@link #AUTO} indicates that the reduction option will be determined by the usage context. For + * almost all cases this defaults to {@link #SUM_OVER_BATCH_SIZE}. + * + *

{@link #NONE} Weighted losses with one dimension reduced (axis=-1, or axis specified by loss + * function). + * + *

{@link #SUM} Scalar sum of weighted losses. + * + *

{@link #SUM_OVER_BATCH_SIZE} Scalar SUM divided by number of elements in losses. + */ +public enum Reduction { + AUTO, + NONE, + SUM, + SUM_OVER_BATCH_SIZE; + + /** + * Get the Reduction based on name + * + * @param name the name of the reduction + * @return the Reduction + */ + public static Reduction ofName(String name) { + return Reduction.valueOf(name.toUpperCase()); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/SparseCategoricalCrossentropy.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/SparseCategoricalCrossentropy.java new file mode 100644 index 00000000000..5586a4da889 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/SparseCategoricalCrossentropy.java @@ -0,0 +1,218 @@ +/* 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.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 crossentropy loss between labels and predictions. + * + *

Use this crossentropy loss function when there are two or more label classes. The labels are + * expected to be provided as integers. If you want to provide labels using one-hot + * representation, please use {@link CategoricalCrossentropy} loss. There should be # classes + * floating point values per feature for predictions and a single floating + * point value per feature for label. + * + *

In the snippet below, there is a single floating point value per example for labels + * and # classes floating pointing values per example for predictions + * . The shape of labels is [batch_size] and the shape of + * predictions is [batch_size, num_classes]. + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[] {1, 2});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.05f, 0.95f, 0f}, {0.1f, 0.8f, 0.1f}});
+ *    SparseCategoricalCrossentropy sparseCCE = new SparseCategoricalCrossentropy(tf);
+ *    Operand<TFloat32> result = sparseCCE.call(labels, predictions);
+ *    // produces 1.177f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {0.3f, 0.7f});
+ *    Operand<TFloat32> result = sparseCCE.call(labels, predictions, sampleWeight);
+ *    // produces 0.814f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    SparseCategoricalCrossentropy sparseCCE = new SparseCategoricalCrossentropy(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = sparseCCE.call(labels, predictions);
+ *    // produces 2.354f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    SparseCategoricalCrossentropy sparseCCE = new SparseCategoricalCrossentropy(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = sparseCCE.call(labels, predictions);
+ *    // produces [0.0513f, 2.303f]
+ *
+ */ +public class SparseCategoricalCrossentropy extends Loss { + public static final boolean FROM_LOGITS_DEFAULT = false; + public static final int AXIS_DEFAULT = -1; + + private final boolean fromLogits; + private final int axis; + + /** + * Creates a SparseCategoricalCrossentropy loss using {@link Class#getSimpleName()} as the loss + * name, a Loss Reduction of {@link Loss#REDUCTION_DEFAULT}, and fromLogits={@link #FROM_LOGITS_DEFAULT}. + * + * @param tf the TensorFlow Ops + */ + public SparseCategoricalCrossentropy(Ops tf) { + this(tf, null, FROM_LOGITS_DEFAULT, REDUCTION_DEFAULT, AXIS_DEFAULT); + } + + /** + * Creates a SparseCategoricalCrossentropy loss using a Loss Reduction of {@link Loss#REDUCTION_DEFAULT}, + * and fromLogits={@link #FROM_LOGITS_DEFAULT}. + * + * @param tf the TensorFlow Ops + * @param name the name of this loss function + */ + public SparseCategoricalCrossentropy(Ops tf, String name) { + this(tf, name, FROM_LOGITS_DEFAULT, REDUCTION_DEFAULT, AXIS_DEFAULT); + } + + /** + * Creates a SparseCategoricalCrossentropy loss using {@link Class#getSimpleName()} as the loss + * name, with Reduction.AUTO and fromLogits={@link #FROM_LOGITS_DEFAULT}. + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to loss. + */ + public SparseCategoricalCrossentropy(Ops tf, Reduction reduction) { + this(tf, null, FROM_LOGITS_DEFAULT, reduction, AXIS_DEFAULT); + } + + /** + * Creates a SparseCategoricalCrossentropy loss with Reduction.AUTO and fromLogits={@link + * #FROM_LOGITS_DEFAULT}. + * + * @param tf the TensorFlow Ops + * @param name the name of this loss function + * @param reduction Type of Reduction to apply to loss. + */ + public SparseCategoricalCrossentropy(Ops tf, String name, Reduction reduction) { + this(tf, name, FROM_LOGITS_DEFAULT, reduction, AXIS_DEFAULT); + } + + /** + * Creates a SparseCategoricalCrossentropy using a Loss Reduction of {@link Loss#REDUCTION_DEFAULT}, and + * fromLogits={@link #FROM_LOGITS_DEFAULT}. + * + * @param tf the TensorFlow Ops + * @param name the name of this loss function + * @param fromLogits Whether to interpret predictions as a tensor of logit values + */ + public SparseCategoricalCrossentropy(Ops tf, String name, boolean fromLogits) { + this(tf, name, fromLogits, REDUCTION_DEFAULT, AXIS_DEFAULT); + } + + /** + * Creates a SparseCategoricalCrossentropy loss using {@link Class#getSimpleName()} as the loss + * name, a Loss Reduction of {@link Loss#REDUCTION_DEFAULT} and fromLogits={@link #FROM_LOGITS_DEFAULT}. + * + * @param tf the TensorFlow Ops + * @param fromLogits Whether to interpret predictions as a tensor of logit values + */ + public SparseCategoricalCrossentropy(Ops tf, boolean fromLogits) { + this(tf, null, fromLogits, REDUCTION_DEFAULT, AXIS_DEFAULT); + } + + /** + * Creates a SparseCategoricalCrossentropy loss using {@link Class#getSimpleName()} as the loss + * name, + * + * @param tf the TensorFlow Ops + * @param fromLogits Whether to interpret predictions as a tensor of logit values + * @param reduction Type of Reduction to apply to loss. + */ + public SparseCategoricalCrossentropy(Ops tf, boolean fromLogits, Reduction reduction) { + this(tf, null, fromLogits, reduction, AXIS_DEFAULT); + } + + /** + * Creates a SparseCategoricalCrossentropy + * + * @param tf the TensorFlow Ops + * @param name the name of this loss function + * @param fromLogits Whether to interpret predictions as a tensor of logit values + * @param reduction Type of Reduction to apply to loss. + * @param axis The channels axis. axis=-1 corresponds to data format `Channels Last' + * and axis=1 corresponds to data format 'Channels First'. + */ + public SparseCategoricalCrossentropy( + Ops tf, String name, boolean fromLogits, Reduction reduction, int axis) { + super(tf, name, reduction); + this.fromLogits = fromLogits; + this.axis = axis; + } + + /** + * Generates an Operand the 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 broadcast 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 The data type of the predictions, sampleWeights and loss. + * @param The data type of the labels. + * @return the loss + * @throws IllegalArgumentException if the predictions are outside the range [0.-1.]. + */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + Operand 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 losses = + Losses.sparseCategoricalCrossentropy(getTF(), labels, lPredictions, fromLogits, axis); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/SquaredHinge.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/SquaredHinge.java new file mode 100644 index 00000000000..182ce592e55 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/SquaredHinge.java @@ -0,0 +1,140 @@ +/* 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.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 squared hinge loss between labels and predictions. + * + *

loss = square(maximum(1 - labels * predictions, 0)) + * + *

labels values are expected to be -1 or 1. If binary (0 or 1) labels are provided, they will be + * converted to -1 or 1. + * + *

Standalone usage: + * + * 

+ *    Operand<TFloat32> labels =
+ *        tf.constant(new float[][] {{0., 1.}, {0., 0.}});
+ *    Operand<TFloat32> predictions =
+ *        tf.constant(new float[][] {{0.6f, 0.4f}, {0.4f, 0.6f}});
+ *    SquaredHinge squaredHinge = new SquaredHinge(tf);
+ *    Operand<TFloat32> result = squaredHinge.call(labels, predictions);
+ *    // produces 1.86f
+ *
+ * + *

Calling with sample weight: + * + * 

+ *    Operand<TFloat32> sampleWeight = tf.constant(new float[] {1.f, 0.f});
+ *    Operand<TFloat32> result = squaredHinge.call(labels, predictions,
+ *                                                  sampleWeight);
+ *    // produces 0.73f
+ *
+ * + *

Using SUM reduction type: + * + * 

+ *    SquaredHinge squaredHinge = new SquaredHinge(tf, Reduction.SUM);
+ *    Operand<TFloat32> result = squaredHinge.call(labels, predictions);
+ *    // produces 3.72f
+ *
+ * + *

Using NONE reduction type: + * + * 

+ *    SquaredHinge squaredHinge = new SquaredHinge(tf, Reduction.NONE);
+ *    Operand<TFloat32> result = squaredHinge.call(labels, predictions);
+ *    // produces [1.46f, 2.26f]
+ *
+ */ +public class SquaredHinge extends Loss { + + /** + * Creates a Squared Hinge Loss using {@link Class#getSimpleName()} as the loss name and a Loss + * Reduction of {@link Loss#REDUCTION_DEFAULT} + * + * @param tf the TensorFlow Ops + */ + public SquaredHinge(Ops tf) { + super(tf); + } + + /** + * Creates a Squared Hinge Loss using {@link Class#getSimpleName()} as the loss name + * + * @param tf the TensorFlow Ops + * @param reduction Type of Reduction to apply to the loss. + */ + public SquaredHinge(Ops tf, Reduction reduction) { + super(tf, null, reduction); + } + + /** + * Creates a Squared Hinge + * + * @param tf the TensorFlow Ops + * @param name the name of the loss + * @param reduction Type of Reduction to apply to the loss. + */ + public SquaredHinge(Ops tf, String name, Reduction reduction) { + super(tf, name, reduction); + } + + /** + * Generates an Operand that calculates the loss. + * + *

If run in Graph mode, the computation will throw {@link + * org.tensorflow.exceptions.TFInvalidArgumentException} if the label values are not in the set + * [-1., 0., 1.]. In Eager Mode, this call will throw {@link IllegalArgumentException}, if the + * label values are not in the set [-1., 0., 1.]. + * + * @param labels the truth values or labels, must be either -1, 0, or 1. Values are expected to be + * -1 or 1. If binary (0 or 1) labels are provided they will be converted to -1 or 1. + * @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 broadcast 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 The data type of the predictions, sampleWeights and loss. + * @param The data type of the labels. + * @return the loss + * @throws IllegalArgumentException if the predictions are outside the range [0.-1.]. + */ + @Override + public Operand call( + Operand labels, Operand predictions, Operand sampleWeights) { + @SuppressWarnings("unchecked") + Operand tLabels = predictions.asOutput().dataType() == labels.asOutput().dataType() ? + (Operand)labels : + cast(tf, labels, predictions.asOutput().dataType()); + tLabels = LossesHelper.valueCheck( + getTF(), + "labels value check [-1, 0, 1]", + tLabels, + cast(getTF(), getTF().constant(new int[] { -1, 0, 1}), + predictions.asOutput().dataType())); + Operand losses = Losses.squaredHinge(getTF(), tLabels, predictions); + return LossesHelper.computeWeightedLoss(getTF(), losses, getReduction(), sampleWeights); + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/impl/LossTuple.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/impl/LossTuple.java new file mode 100644 index 00000000000..2104937a979 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/impl/LossTuple.java @@ -0,0 +1,67 @@ +/* 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.losses.impl; + +import org.tensorflow.Operand; +import org.tensorflow.types.family.TNumber; + +/** + * A helper class for loss methods to return labels, target, and sampleWeights + * + * @param the data type of the LossTuple entries. + */ +public class LossTuple { + private final Operand labels; + private final Operand target; + private final Operand sampleWeights; + + /** + * Creates a LossTuple of Operands for labels, target, and sampleWeights + * + * @param labels the labels + * @param target the losses or target + */ + public LossTuple(Operand labels, Operand target) { + this(labels, target, null); + } + + /** + * Creates a LossTuple of Operands for labels, target, and sampleWeights + * + * @param labels the labels + * @param target the losses or target + * @param sampleWeights the sample weights + */ + public LossTuple(Operand labels, Operand target, Operand sampleWeights) { + this.labels = labels; + this.target = target; + this.sampleWeights = sampleWeights; + } + + /** @return the labels */ + public Operand getLabels() { + return labels; + } + + /** @return the target */ + public Operand getTarget() { + return target; + } + + /** @return the sampleWeights */ + public Operand getSampleWeights() { + return sampleWeights; + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/impl/LossesHelper.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/impl/LossesHelper.java new file mode 100644 index 00000000000..463296a1f50 --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/losses/impl/LossesHelper.java @@ -0,0 +1,417 @@ +/* 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.losses.impl; + +import org.tensorflow.DataType; +import org.tensorflow.Operand; +import org.tensorflow.framework.losses.Reduction; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.op.core.AssertThat; +import org.tensorflow.op.core.ReduceSum; +import org.tensorflow.op.core.SetDiff1d; +import org.tensorflow.op.core.Squeeze; +import org.tensorflow.types.TBool; +import org.tensorflow.types.TInt32; +import org.tensorflow.types.family.TNumber; + +import java.util.Arrays; +import java.util.Collections; + +import static org.tensorflow.framework.utils.CastHelper.cast; + +/** + * These are helper methods for Losses and Metrics and will be module private when Java modularity is applied to + * TensorFlow Java. These methods should not be used outside of the losses and metrics packages. + */ +public class LossesHelper { + + /** + * Squeeze or expand last dimension if needed with a sampleWeights of one. + * + *

    + *
  1. Squeezes last dim of predictions or labels if their rank + * differs by 1 (using {@link #removeSqueezableDimensions}). + *
  2. Squeezes or expands last dim of sampleWeight if its rank differs by 1 from + * the new rank of predictions. If sampleWeight is scalar, it is + * kept scalar./li> + *
+ * + * @param tf the TensorFlow Ops + * @param predictions Predicted values, a Operand of arbitrary dimensions. + * @param labels Optional label Operand whose dimensions match prediction + * . + * @return LossTuple of prediction, label,sampleWeight will + * be null. Each of them possibly has the last dimension squeezed, sampleWeight + * could be extended by one dimension. If sampleWeight is null, (prediction, + * label) is returned. + */ + public static LossTuple squeezeOrExpandDimensions( + Ops tf, Operand labels, Operand predictions) { + return squeezeOrExpandDimensions(tf, labels, predictions, null); + } + + /** + * Squeeze or expand last dimension if needed. + * + *
    + *
  1. Squeezes last dim of predictions or labels if their rank do not + * differ by 1. + *
  2. Squeezes or expands last dim of sampleWeight if its rank differs by 1 from + * the new rank of predictions. If sampleWeight is scalar, it is + * kept scalar. + *
+ * + * @param tf the TensorFlow Ops + * @param predictions Predicted values, a Operand of arbitrary dimensions. + * @param labels Optional label Operand whose dimensions match prediction + * . + * @param sampleWeights Optional sample weight(s) Operand whose dimensions match + * prediction. + * @return LossTuple of prediction, labels and sampleWeight. + * Each of them possibly has the last dimension squeezed, sampleWeight could be + * extended by one dimension. If sampleWeight is null, only the possibly shape modified predictions and labels are + * returned. + */ + public static LossTuple squeezeOrExpandDimensions( + Ops tf, Operand labels, Operand predictions, Operand sampleWeights) { + + Shape predictionsShape = predictions.asOutput().shape(); + long predictionsRank = predictionsShape.numDimensions(); + + // Default case when no modifications are made. + LossTuple lossTuple = new LossTuple<>(labels, predictions, sampleWeights); + if (labels != null) { + Shape labelsShape = labels.asOutput().shape(); + long labelsRank = labelsShape.numDimensions(); + if (labelsRank != Shape.UNKNOWN_SIZE && predictionsRank != Shape.UNKNOWN_SIZE) { + // Use static rank for 'label' and 'prediction'. + if (predictionsRank - labelsRank != 1 || predictionsShape.size(-1) == 1) { + lossTuple = removeSqueezableDimensions(tf, labels, predictions); + } + } else { // use dynamic rank + lossTuple = removeSqueezableDimensions(tf, labels, predictions); + } + } + if (sampleWeights == null) { // nothing more to do. + return lossTuple; + } + Shape weightsShape = sampleWeights.asOutput().shape(); + long weightsRank = weightsShape.numDimensions(); + if (weightsRank == 0) { // scalar + return new LossTuple<>(lossTuple.getLabels(), lossTuple.getTarget(), sampleWeights); + } + + if (predictionsRank != Shape.UNKNOWN_SIZE && weightsRank != Shape.UNKNOWN_SIZE) { + + if (weightsRank - predictionsRank == 1) { + sampleWeights = tf.squeeze(sampleWeights); + } else if (predictionsRank - weightsRank == 1) { + sampleWeights = tf.expandDims(sampleWeights, tf.constant(-1L)); + } + return new LossTuple<>(lossTuple.getLabels(), lossTuple.getTarget(), sampleWeights); + } + // Use dynamic rank. + Operand weightsRankTensor = tf.rank(sampleWeights); + Operand rankDiff = tf.math.sub(weightsRankTensor, tf.rank(predictions)); + sampleWeights = + tf.select( + tf.math.equal(weightsRankTensor, tf.constant(0)), + sampleWeights, + maybeAdjustWeights(tf, sampleWeights, rankDiff)); + return new LossTuple<>(lossTuple.getLabels(), lossTuple.getTarget(), sampleWeights); + } + + /** + * Squeeze or expand the sampleWeight based on the rank difference + * + *

If the rank difference is +1, squeeze the last dimension of sampleWeight, If the rank + * difference is -1, expand the last dimension of sampleWeight. Otherwise, leave the shape of + * sampleWeight as is. + * + * @param tf the TensorFlow Ops + * @param sampleWeight the sample weights + * @param rankDiff the difference in rank + * @param the data type for the Operands. + * @return the adjusted sampleWeight + */ + private static Operand maybeAdjustWeights( + Ops tf, Operand sampleWeight, Operand rankDiff) { + return tf.select( + tf.math.equal(rankDiff, tf.constant(1)), + tf.squeeze(sampleWeight, Squeeze.axis(Collections.singletonList(-1L))), + maybeExpandWeights(tf, sampleWeight, rankDiff)); + } + + /** + * Expand the last dimension of sampleWeight. if the rank difference is -1. + * + * @param tf the TensorFlow Ops + * @param sampleWeight the sample weights + * @param rankDiff the difference in rank + * @param the data type for the Operands. + * @return the adjusted sampleWeight + */ + private static Operand maybeExpandWeights( + Ops tf, Operand sampleWeight, Operand rankDiff) { + return tf.select( + tf.math.equal(rankDiff, tf.constant(-1)), + tf.expandDims(sampleWeight, tf.constant(-1)), + sampleWeight); + } + + /** + * Squeeze last dim if ranks differ from expected by exactly 1. + * + * @param tf the TensorFlowOps + * @param labels Label values, a Tensor whose dimensions match predictions + * . + * @param predictions Predicted values, a Tensor of arbitrary dimensions. + * @return labels and predictions, possibly with last dim squeezed. + */ + public static LossTuple removeSqueezableDimensions( + Ops tf, Operand labels, Operand predictions) { + return removeSqueezableDimensions(tf, labels, predictions, 0); + } + + /** + * Squeeze last dim if ranks differ from expected by exactly 1. + * + * @param tf the TensorFlowOps + * @param labels Label values, a Operand whose dimensions match predictions + * . + * @param predictions Predicted values, a Tensor of arbitrary dimensions. + * @param expectedRankDiff Expected result of rank(predictions) - rank(labels). + * @return labels and predictions, possibly with last dim squeezed. + */ + public static LossTuple removeSqueezableDimensions( + Ops tf, Operand labels, Operand predictions, int expectedRankDiff) { + + tf = tf.withSubScope("removeSqueezableDimensions"); + Shape predictionsShape = predictions.asOutput().shape(); + int predictionsRank = predictionsShape.numDimensions(); + Shape labelsShape = labels.asOutput().shape(); + int labelsRank = labelsShape.numDimensions(); + + if (predictionsRank != Shape.UNKNOWN_SIZE || labelsRank != Shape.UNKNOWN_SIZE) { + // Use static rank. + int rankDiff = predictionsRank - labelsRank; + if (rankDiff == expectedRankDiff + 1 && Shape.isCompatible(predictionsShape.size(-1), 1)) { + predictions = tf.squeeze(predictions); + } else if (rankDiff == expectedRankDiff - 1 && Shape.isCompatible(labelsShape.size(-1), 1)) { + labels = tf.squeeze(labels); + } + return new LossTuple<>(labels, predictions); + } + // Use dynamic rank. + + // TODO Operand rankDiff = tf.math.sub(tf.rank(predictions), tf.rank(labels)); + if (predictionsRank == Shape.UNKNOWN_SIZE && Shape.isCompatible(predictionsShape.size(-1), 1)) { + /* + * TODO, if we ever get a select that does lazy evaluation, but for now do the tf.squeeze + * predictions = tf.select( tf.math.equal(tf.constant(expectedRankDiff+1),rankDiff ), + * tf.squeeze(predictions, Squeeze.axis(Arrays.asList(-1L))), predictions ); * + */ + predictions = tf.squeeze(predictions, Squeeze.axis(Collections.singletonList(-1L))); + } + if (labelsRank == Shape.UNKNOWN_SIZE && Shape.isCompatible(labelsShape.size(-1), 1)) { + /* + * TODO, if we ever get a select that does lazy evaluation labels = tf.select( + * tf.math.equal(tf.constant(expectedRankDiff+1),rankDiff ), tf.squeeze(labels, + * Squeeze.axis(Arrays.asList(-1L))), predictions ); * + */ + labels = tf.squeeze(labels, Squeeze.axis(Collections.singletonList(-1L))); + } + return new LossTuple<>(labels, predictions); + } + + /** + * Computes the weighted loss + * + * @param tf the TensorFlow Ops + * @param loss the unweighted loss + * @param reduction the type of reduction + * @param sampleWeight the sample weight, if null then this defaults to one. + * @param the data type of the loss + * @return the weighted loss + */ + public static Operand computeWeightedLoss( + Ops tf, Operand loss, Reduction reduction, Operand sampleWeight) { + DataType dataType = loss.asOutput().dataType(); + if (sampleWeight == null) { + sampleWeight = cast(tf, tf.constant(1), dataType); + } + LossTuple result = squeezeOrExpandDimensions(tf, null, loss, sampleWeight); + loss = result.getTarget(); + sampleWeight = result.getSampleWeights(); + + Operand weightedLosses = tf.math.mul(loss, cast(tf, sampleWeight, dataType)); + loss = reduceWeightedLoss(tf, weightedLosses, reduction); + return cast(tf, loss, dataType); + } + + /** + * Reduces the weighted loss based on the reduction type + * + * @param tf the TensorFlow Ops + * @param weightedLoss the weighted loss + * @param reduction the type of reduction + * @param the data type of the weighted loss + * @return the reduced weighted loss + */ + private static Operand reduceWeightedLoss( + Ops tf, Operand weightedLoss, Reduction reduction) { + Operand loss; + if (reduction == Reduction.NONE) { + loss = weightedLoss; + } else { + loss = + tf.reduceSum(weightedLoss, allAxes(tf, weightedLoss), ReduceSum.keepDims(Boolean.FALSE)); + if (reduction == Reduction.AUTO || reduction == Reduction.SUM_OVER_BATCH_SIZE) { + loss = safeMean(tf, loss, weightedLoss.asOutput().shape().size()); + } + } + return loss; + } + + /** + * Computes a safe mean of the losses. + * + * @param tf the TensorFlow Ops + * @param losses Operand whose elements contain individual loss measurements. + * @param numElements The number of measurable elements in losses. + * @param the data type of the losses + * @return A scalar representing the mean of losses. If numElements is + * zero, then zero is returned. + */ + public static Operand safeMean( + Ops tf, Operand losses, long numElements) { + Operand totalLoss = tf.reduceSum(losses, allAxes(tf, losses)); + return tf.math.divNoNan( + totalLoss, cast(tf, tf.constant(numElements), losses.asOutput().dataType())); + } + + /** + * Gets a Constant integer array representing all the axes of the operand. + * + * @param tf the TensorFlow Ops + * @param op the TensorFlow Ops + * @param the type of Operand + * @return a Constant that represents all the axes of the operand. + */ + public static Operand allAxes(Ops tf, Operand op) { + int rank = op.asOutput().shape().numDimensions(); + if (rank != Shape.UNKNOWN_SIZE) { + int[] axes = new int[rank]; + for (int i = 0; i < rank; i++) { + axes[i] = i; + } + return tf.constant(axes); + } else { + return tf.range(tf.constant(0), tf.rank(op), tf.constant(1)); + } + } + + /** + * Perform an inclusive range check on the values + * + * @param tf the TensorFlow Ops + * @param prefix A String prefix to include in the error message + * @param values the values to check + * @param minValue the minimum value + * @param maxValue the maximum value + * @param the datatype for the values + * @return the values possibly with control dependencies if the TensorFlow Ops represents a Graph + * Session + * @throws IllegalArgumentException if the TensorFlow Ops represents an Eager Session + */ + public static Operand rangeCheck( + Ops tf, String prefix, Operand values, Operand minValue, Operand maxValue) { + Operand allDims = allAxes(tf, values); + Operand cond = + tf.math.logicalAnd( + tf.reduceAll(tf.math.greaterEqual(values, minValue), allDims), + tf.reduceAll(tf.math.lessEqual(values, maxValue), allDims)); + // Graph and Eager mode need to be handled differently, control dependencies are not allowed in + // Eager mode + if (tf.scope().env().isGraph()) { + AssertThat assertThat = + tf.assertThat( + cond, + Arrays.asList( + tf.constant(prefix), + tf.constant(": values out of range, "), + tf.constant("minimum = "), + minValue, + tf.constant(", maximum = "), + maxValue)); + Ops ltf = + tf.withSubScope("rangeCheck") + .withControlDependencies(Collections.singletonList(assertThat)); + return ltf.identity(values); + } else if (!cond.asOutput().data().getBoolean()) + throw new IllegalArgumentException(String.format("%s : values out of range", prefix)); + else return values; + } + + /** + * Checks to see if all the values are in the allowed values set. Running the operand in Graph + * mode will throw {@link org.tensorflow.exceptions.TFInvalidArgumentException}, if at least one + * value is not in the allowed values set. In Eager mode, this method will throw an {@link + * IllegalArgumentException} if at least one value is not in the allowed values set. + * + * @param tf The TensorFlow Ops + * @param prefix A String prefix to include in the error message + * @param values the values to check + * @param allowedValues the allowed values + * @param the data type for values and allowed values + * @return the values possibly with control dependencies if the TensorFlow Ops represents a Graph + * Session + * @throws IllegalArgumentException if the Session is in Eager mode and at least one value is not + * in the allowed values set + */ + public static Operand valueCheck( + Ops tf, String prefix, Operand values, Operand allowedValues) { + Operand flatValues = + tf.reshape(values, tf.constant(Shape.of(values.asOutput().shape().size()))); + SetDiff1d diff = tf.setDiff1d(flatValues, allowedValues, TInt32.DTYPE); + long diffSize = diff.out().asOutput().shape().size(); + + if (diffSize != Shape.UNKNOWN_SIZE) { + if (diffSize != 0) { // at least 1 value in the diff did not match the allowed values. + throw new IllegalArgumentException(String.format("%s : values not in value set,", prefix)); + } else return values; + } else { // use dynamic shape + Operand cond = tf.math.equal(tf.shape.size(tf.shape(diff.out())), tf.constant(0)); + // Graph and Eager mode need to be handled differently, control dependencies are not allowed + // in Eager mode + if (tf.scope().env().isGraph()) { + AssertThat assertThat = + tf.assertThat( + cond, + Arrays.asList( + tf.constant(prefix), + tf.constant(": values not in value set, values = "), + values)); + Ops ltf = + tf.withSubScope("valueCheck") + .withControlDependencies(Collections.singletonList(assertThat)); + return ltf.identity(values); + } else if (!cond.asOutput().data().getBoolean()) + throw new IllegalArgumentException(String.format("%s : values not in value set", prefix)); + else return values; + } + } +} diff --git a/tensorflow-framework/src/main/java/org/tensorflow/framework/utils/CastHelper.java b/tensorflow-framework/src/main/java/org/tensorflow/framework/utils/CastHelper.java new file mode 100644 index 00000000000..aec75e6078a --- /dev/null +++ b/tensorflow-framework/src/main/java/org/tensorflow/framework/utils/CastHelper.java @@ -0,0 +1,43 @@ +/* + * 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.utils; + +import org.tensorflow.DataType; +import org.tensorflow.Operand; +import org.tensorflow.op.Ops; +import org.tensorflow.types.family.TType; + +/** A helper class for casting an Operand */ +public class CastHelper { + + /** + * Casts an operand to the desired type. + * + * @param tf The TensorFlow Ops + * @param value the value to be cast + * @param requiredType the required data type + * @param the required data type + * @param the original data type of the value + * @return the value cast to the required data type. + */ + @SuppressWarnings("unchecked") + public static Operand cast( + Ops tf, Operand value, DataType requiredType) { + return (value.asOutput().dataType() == requiredType) + ? (Operand) value + : tf.dtypes.cast(value, requiredType); + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/BinaryCrossentropyTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/BinaryCrossentropyTest.java new file mode 100644 index 00000000000..d2128b80839 --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/BinaryCrossentropyTest.java @@ -0,0 +1,226 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class BinaryCrossentropyTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class BinaryCrossentropy. */ + @Test + public void testAllCorrectUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + BinaryCrossentropy instance = new BinaryCrossentropy(tf); + float[] trueArray = {1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + + Operand loss = instance.call(yTrue, yTrue); + + float expected = 0.0f; + testSession.evaluate(expected, loss); + // Test with logits. + float[] logitsArray = { + 100.0f, -100.0f, -100.0f, + -100.0f, 100.0f, -100.0f, + -100.0f, -100.0f, 100.0f + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new BinaryCrossentropy(tf, true); + + loss = instance.call(yTrue, logits); + testSession.evaluate(expected, loss); + } + } + + @Test + public void testInvalidPredictionsRange() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Class catchClass = + tfMode == TestSession.Mode.EAGER + ? IllegalArgumentException.class + : org.tensorflow.exceptions.TFInvalidArgumentException.class; + assertThrows( + catchClass, + () -> { + Ops tf = testSession.getTF(); + BinaryCrossentropy instance = new BinaryCrossentropy(tf); + float[] trueArray = {1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f}; + float[] predArray = {2f, 1f, -1f, 0f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 2))); + + Operand loss = instance.call(yTrue, yPred); + testSession.run(loss); + }); + } + } + + /** Test of call method, of class BinaryCrossentropy. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + BinaryCrossentropy instance = new BinaryCrossentropy(tf); + float[] trueArray = {1f, 0f, 1f, 0f}; + float[] predArray = {1f, 1f, 1f, 0f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 2))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 2))); + Operand loss = instance.call(yTrue, yPred); + float expected = 3.83331f; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] trueArray1 = {1f, 0f, 1f, 0f, 1f, 1f}; + float[] logitsArray = { + 100.0f, -100.0f, 100.0f, + 100.0f, 100.0f, -100.0f + }; + Operand yTrue1 = tf.reshape(tf.constant(trueArray1), tf.constant(Shape.of(2, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(2, 3))); + instance = new BinaryCrossentropy(tf, true); + loss = instance.call(yTrue1, logits); + expected = 33.33333f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class BinaryCrossentropy. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + BinaryCrossentropy instance = new BinaryCrossentropy(tf); + float[] trueArray = {1f, 0f, 1f, 0f}; + float[] predArray = {1f, 1f, 1f, 0f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 2))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 2))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 8.816612f; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] trueArray1 = {1f, 0f, 1f, 0f, 1f, 1f}; + float[] logitsArray = { + 100.0f, -100.0f, 100.0f, + 100.0f, 100.0f, -100.0f + }; + Operand yTrue1 = tf.reshape(tf.constant(trueArray1), tf.constant(Shape.of(2, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(2, 3))); + instance = new BinaryCrossentropy(tf, true); + loss = instance.call(yTrue1, logits, sampleWeight); + expected = 76.66667f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + BinaryCrossentropy instance = new BinaryCrossentropy(tf); + float[] trueArray = {1f, 0f, 1f, 0f}; + float[] predArray = {1f, 1f, 1f, 0f}; + float[] sampleWeightArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 2))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 2))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleWeightArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 4.59997f; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] trueArray1 = {1f, 0f, 1f, 0f, 1f, 1f}; + float[] logitsArray = { + 100.0f, -100.0f, 100.0f, + 100.0f, 100.0f, -100.0f + }; + float[] sampleWeightArray1 = {4f, 3f}; + Operand yTrue1 = tf.reshape(tf.constant(trueArray1), tf.constant(Shape.of(2, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight1 = tf.constant(sampleWeightArray1); + instance = new BinaryCrossentropy(tf, true); + loss = instance.call(yTrue1, logits, sampleWeight1); + expected = 100f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testNoReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + // Test with logits. + float[] trueArray = {1f, 0f, 1f, 0f, 1f, 1f}; + float[] logitsArray = { + 100.0f, -100.0f, 100.0f, + 100.0f, 100.0f, -100.0f + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(2, 3))); + BinaryCrossentropy instance = + new BinaryCrossentropy( + tf, true, BinaryCrossentropy.LABEL_SMOOTHING_DEFAULT, Reduction.NONE); + Operand loss = instance.call(yTrue, logits); + Float[] expected = {0.f, 66.666664f}; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testLabelSmoothing() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float labelSmoothing = 0.1f; + float[] trueArray = {1f, 0f, 1f}; + float[] logitsArray = {100.0f, -100.0f, -100.0f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(1, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(1, 3))); + + BinaryCrossentropy instance = new BinaryCrossentropy(tf, true, labelSmoothing); + Operand loss = instance.call(yTrue, logits); + float expected = (100.0f + 50.0f * labelSmoothing) / 3.0f; + testSession.evaluate(expected, loss); + } catch (Exception expected) { + + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CategoricalCrossentropyTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CategoricalCrossentropyTest.java new file mode 100644 index 00000000000..13b287de3cd --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CategoricalCrossentropyTest.java @@ -0,0 +1,263 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; +import org.tensorflow.types.TInt32; +import org.tensorflow.types.TInt64; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class CategoricalCrossentropyTest { + + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class CategoricalCrossentropy. */ + @Test + public void testAllCorrectUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + long[] trueArray = { + 1L, 0L, 0L, + 0L, 1L, 0L, + 0L, 0L, 1L + }; + float[] predArray = { + 1.F, 0.F, 0.F, + 0.F, 1.F, 0.F, + 0.F, 0.F, 1.F + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + CategoricalCrossentropy instance = new CategoricalCrossentropy(tf); + Operand loss = instance.call(yTrue, yPred); + float expected = 0F; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 10.F, 0.F, 0.F, + 0.F, 10.F, 0.F, + 0.F, 0.F, 10.F + }; + yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new CategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits); + testSession.setEpsilon(1e-3F); + testSession.evaluate(0.0F, loss); + } + } + + @Test + public void testInvalidPredictionsRange() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Class catchClass = + tfMode == TestSession.Mode.EAGER + ? IllegalArgumentException.class + : org.tensorflow.exceptions.TFInvalidArgumentException.class; + assertThrows( + catchClass, + () -> { + Ops tf = testSession.getTF(); + CategoricalCrossentropy instance = new CategoricalCrossentropy(tf); + float[] trueArray = { + 1L, 0L, 0L, + 0L, 1L, 0L, + 0L, 0L, 1L + }; + float[] predArray = { + -1.F, 0.F, 0.F, + 0.F, 1.F, 0.F, + 0.F, 0.F, 1.F + }; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 2))); + + Operand loss = instance.call(yTrue, yPred); + testSession.run(loss); + }); + } + } + + /** Test of call method, of class CategoricalCrossentropy. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalCrossentropy instance = new CategoricalCrossentropy(tf); + int[] trueArray = {1, 0, 0, 0, 1, 0, 0, 0, 1}; + float[] predArray = { + .9F, .05F, .05F, + .5F, .89F, .6F, + .05F, .01F, .94F + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 0.32396814F; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new CategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits); + expected = 0.0573755F; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class CategoricalCrossentropy. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + int[] trueArray = { + 1, 0, 0, + 0, 1, 0, + 0, 0, 1 + }; + float[] predArray = { + .9F, .05F, .05F, + .5F, .89F, .6F, + .05F, .01F, .94F + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + Operand sampleWeight = tf.constant(2.3F); + + CategoricalCrossentropy instance = new CategoricalCrossentropy(tf); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = .7451267F; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new CategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits, sampleWeight); + expected = 0.13196386F; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSsampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalCrossentropy instance = new CategoricalCrossentropy(tf); + float[] sampeWeightArray = {1.2F, 3.4F, 5.6F}; + int[] trueArray = { + 1, 0, 0, + 0, 1, 0, + 0, 0, 1 + }; + float[] predArray = { + .9F, .05F, .05F, + .5F, .89F, .6F, + .05F, .01F, .94F + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampeWeightArray), tf.constant(Shape.of(3, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 1.0696F; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new CategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits, sampleWeight); + expected = 0.31829F; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testNoReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + // Test with logits. + int[] trueArray = {1, 0, 0, 0, 1, 0, 0, 0, 1}; + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + CategoricalCrossentropy instance = + new CategoricalCrossentropy(tf, true, 0.0F, Reduction.NONE); + Operand loss = instance.call(yTrue, logits); + Float[] expected = {0.001822F, 0.000459F, 0.169846F}; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testLabelSmoothing() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float labelSmoothing = 0.1F; + int[] trueArray = {1, 0, 0}; + float[] logitsArray = {100.0F, -100.0F, -100.0F}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(1, 3))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(1, 3))); + + CategoricalCrossentropy instance = new CategoricalCrossentropy(tf, true, labelSmoothing); + Operand loss = instance.call(yTrue, logits); + float expected = 400.0F * labelSmoothing / 3.0F; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CategoricalHingeTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CategoricalHingeTest.java new file mode 100644 index 00000000000..b0d0442b3c7 --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CategoricalHingeTest.java @@ -0,0 +1,138 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; +import org.tensorflow.types.TInt32; + +public class CategoricalHingeTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class CategoricalHinge. */ + @Test + public void testReductionNone() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalHinge instance = new CategoricalHinge(tf, Reduction.NONE); + int[] trueArray = {1, 9, 2, -5}; + float[] predArray = {4f, 8f, 12f, 8f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 2))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 2))); + Operand loss = instance.call(yTrue, yPred); + Float[] expected = {0.0f, 65.0f}; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class CategoricalHinge. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalHinge instance = new CategoricalHinge(tf); + int[] trueArray = {1, 9, 2, -5}; + float[] predArray = {4f, 8f, 12f, 8f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 2))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 2))); + Operand loss = instance.call(yTrue, yPred); + float expected = 32.5f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class CategoricalHinge. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalHinge instance = new CategoricalHinge(tf); + int[] trueArray = {1, 9, 2, -5, -2, 6}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 83.95f; + testSession.evaluate(expected, loss); + + Operand loss2 = instance.call(yTrue, yPred, sampleWeight); + testSession.evaluate(loss, loss2); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalHinge instance = new CategoricalHinge(tf); + int[] trueArray = {1, 9, 2, -5, -2, 6}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] weightsNp = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(weightsNp), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 124.1f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalHinge instance = new CategoricalHinge(tf); + int[] trueArray = {1, 9, 2, -5, -2, 6}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CategoricalHinge instance = new CategoricalHinge(tf); + int[] trueArray = {1, 9, 2, -5, -2, 6}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] weightsNp = {3, 6, 5, 0, 4, 2}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(weightsNp), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 4.0f; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CosineSimilarityTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CosineSimilarityTest.java new file mode 100644 index 00000000000..8350d1403ed --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/CosineSimilarityTest.java @@ -0,0 +1,185 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class CosineSimilarityTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class CosineSimilarity. */ + @Test + public void testReductionNone() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + CosineSimilarity instance = new CosineSimilarity(tf, Reduction.NONE); + Shape shape = Shape.of(2, 3); + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(shape)); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(shape)); + Operand loss = instance.call(yTrue, yPred); + Float[] expected = {-0.720488f, 0.3460499f}; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class CosineSimilarity. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] expectedLoss = {0.720488f, -0.3460499f}; + CosineSimilarity instance = new CosineSimilarity(tf); + Shape shape = Shape.of(2, 3); + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(shape)); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(shape)); + Operand loss = instance.call(yTrue, yPred); + float expected = -mean(expectedLoss); + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class CosineSimilarity. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] expectedLoss = {0.720488f, -0.3460499f}; + CosineSimilarity instance = new CosineSimilarity(tf); + Shape shape = Shape.of(2, 3); + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(shape)); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(shape)); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = -mean(mul(expectedLoss, 2.3f)); + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] expectedLoss = {0.720488f, -0.3460499f}; + CosineSimilarity instance = new CosineSimilarity(tf); + float[] weightsArray = {1.2f, 3.4f}; + Shape shape = Shape.of(2, 3); + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(shape)); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(shape)); + Operand sampleWeight = + tf.reshape(tf.constant(weightsArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = -mean(mul(expectedLoss, weightsArray)); + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + CosineSimilarity instance = new CosineSimilarity(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Shape shape = Shape.of(2, 3); + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(shape)); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(shape)); + Operand sampleWeight = tf.constant(0f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + CosineSimilarity instance = new CosineSimilarity(tf); + Shape shape = Shape.of(2, 3, 1); + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(shape)); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(shape)); + float[] weightsArray = {3, 6, 5, 0, 4, 2}; + Operand sampleWeight = + tf.reshape(tf.constant(weightsArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = -2.0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testAxis() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] expectedLoss = {0.720488f, -0.3460499f}; + CosineSimilarity instance = new CosineSimilarity(tf, 1); + Shape shape = Shape.of(2, 3); + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(shape)); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(shape)); + Operand loss = instance.call(yTrue, yPred); + float expected = -mean(expectedLoss); + testSession.evaluate(expected, loss); + } + } + + private float mean(float[] v) { + float sum = 0; + for (float value : v) { + sum += value; + } + return sum / v.length; + } + + private float[] mul(float[] v, float scalar) { + float[] result = new float[v.length]; + for (int i = 0; i < v.length; i++) { + result[i] = v[i] * scalar; + } + return result; + } + + private float[] mul(float[] v, float[] b) { + float[] result = new float[v.length]; + for (int i = 0; i < v.length; i++) { + result[i] = v[i] * b[i]; + } + return result; + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/HingeTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/HingeTest.java new file mode 100644 index 00000000000..4770511207e --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/HingeTest.java @@ -0,0 +1,149 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class HingeTest { + + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class Hinge. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Hinge instance = new Hinge(tf); + float[] trueArray = {0f, 1f, 0f, 1f, 0f, 0f, 1f, 1f}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand loss = instance.call(yTrue, yPred); + float expected = 0.50625f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testInvalidLabelValue() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Class catchClass = + tfMode == TestSession.Mode.EAGER + ? IllegalArgumentException.class + : org.tensorflow.exceptions.TFInvalidArgumentException.class; + assertThrows( + catchClass, + () -> { + Ops tf = testSession.getTF(); + Hinge instance = new Hinge(tf); + float[] trueArray = {2f, 1f, 0f, 1f, 0f, 0f, 1f, 1f}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand loss = instance.call(yTrue, yPred); + testSession.run(loss); + }); + } + } + + /** Test of call method, of class Hinge. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Hinge instance = new Hinge(tf); + float[] trueArray = {0f, 1f, 0f, 1f, 0f, 0f, 1f, 1f}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 1.164375f; + testSession.evaluate(expected, loss); + + // todo Verify we get the same output when the same input is given + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Hinge instance = new Hinge(tf); + float[] sampleArray = {1.2f, 3.4f}; + float[] trueArray = {0f, 1f, 0f, 1f, 0f, 0f, 1f, 1f}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 1.06125f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Hinge instance = new Hinge(tf); + float[] trueArray = {0f, 1f, 0f, 1f, 0f, 0f, 1f, 1f}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Hinge instance = new Hinge(tf, Reduction.AUTO); + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f, 1f, 3f}; + float[] trueArray = {0f, 1f, 0f, 1f, 0f, 0f, 1f, 1f}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 4))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = 2.0125f; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/HuberTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/HuberTest.java new file mode 100644 index 00000000000..d1751f223a1 --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/HuberTest.java @@ -0,0 +1,137 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class HuberTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + @Test + public void testAllCorrect() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {.9f, .2f, .2f, .8f, .4f, .6f}; + + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Huber instance = new Huber(tf); + Operand loss = instance.call(yTrue, yTrue); + float expected = 0.0f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class Huber. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + float[] trueArray = {.9f, .2f, .2f, .8f, .4f, .6f}; + float[] predArray = {1.f, 0.f, 1.f, 1.f, 0.f, 0.f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Huber instance = new Huber(tf); + Operand loss = instance.call(yTrue, yPred); + float expected = 0.10416666666666669f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class Huber. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {.9f, .2f, .2f, .8f, .4f, .6f}; + float[] predArray = {1.f, 0.f, 1.f, 1.f, 0.f, 0.f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Huber instance = new Huber(tf); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0.23958333333333337f; + testSession.evaluate(expected, loss); + + // todo Verify we get the same output when the same input is given + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] sampleArray = {1.2f, 3.4f}; + float[] trueArray = {.9f, .2f, .2f, .8f, .4f, .6f}; + float[] predArray = {1.f, 0.f, 1.f, 1.f, 0.f, 0.f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Huber instance = new Huber(tf); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0.22766666666666668f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] trueArray = {.9f, .2f, .2f, .8f, .4f, .6f}; + float[] predArray = {1.f, 0.f, 1.f, 1.f, 0.f, 0.f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Huber instance = new Huber(tf); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + float[] trueArray = {.9f, .2f, .2f, .8f, .4f, .6f}; + float[] predArray = {1.f, 0.f, 1.f, 1.f, 0.f, 0.f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Huber instance = new Huber(tf); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = .4025f; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/KLDivergenceTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/KLDivergenceTest.java new file mode 100644 index 00000000000..d57b61b18dd --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/KLDivergenceTest.java @@ -0,0 +1,119 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class KLDivergenceTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class KLDivergence. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + KLDivergence instance = new KLDivergence(tf); + float[] predArray = {.4f, .9f, .12f, .36f, .3f, .4f}; + float[] trueArray = {.5f, .8f, .12f, .7f, .43f, .8f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 0.5960738398643668f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class KLDivergence. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + KLDivergence instance = new KLDivergence(tf); + float[] predArray = {.4f, .9f, .12f, .36f, .3f, .4f}; + float[] trueArray = {.5f, .8f, .12f, .7f, .43f, .8f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 1.3709698316880434f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + KLDivergence instance = new KLDivergence(tf); + float[] predArray = {.4f, .9f, .12f, .36f, .3f, .4f}; + float[] trueArray = {.5f, .8f, .12f, .7f, .43f, .8f}; + float[] sampleArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 2.0075711736936492f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + KLDivergence instance = new KLDivergence(tf); + float[] predArray = {.4f, .9f, .12f, .36f, .3f, .4f}; + float[] trueArray = {.5f, .8f, .12f, .7f, .43f, .8f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + KLDivergence instance = new KLDivergence(tf, Reduction.AUTO); + float[] predArray = {.4f, .9f, .12f, .36f, .3f, .4f}; + float[] trueArray = {.5f, .8f, .12f, .7f, .43f, .8f}; + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = 0.2495994912084345f; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/LogCoshTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/LogCoshTest.java new file mode 100644 index 00000000000..c4347b3fccb --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/LogCoshTest.java @@ -0,0 +1,119 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class LogCoshTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class LogCosh. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + LogCosh instance = new LogCosh(tf); + float[] predArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 4.829245330860459f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class LogCosh. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + LogCosh instance = new LogCosh(tf); + float[] predArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 11.107264260979056f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + LogCosh instance = new LogCosh(tf); + float[] predArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 12.001114667519486f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + LogCosh instance = new LogCosh(tf); + float[] predArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + LogCosh instance = new LogCosh(tf, Reduction.AUTO); + float[] predArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = 11.653484271934046f; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanAbsoluteErrorTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanAbsoluteErrorTest.java new file mode 100644 index 00000000000..3498c6d53aa --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanAbsoluteErrorTest.java @@ -0,0 +1,194 @@ +/* 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.losses; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class MeanAbsoluteErrorTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class MeanAbsoluteError. */ + @Test + public void testAllCorrectUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf); + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yTrue); + float expected = 0.0f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanAbsoluteError. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 5.5f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanAbsoluteError. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 12.65f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 81.4f / 6f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf, Reduction.AUTO); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = 83f / 6f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testInvalidSampleWeight() { + for (TestSession.Mode tfMode : tfModes) + Assertions.assertThrows( + IllegalArgumentException.class, + () -> { + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 2))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 83f / 6f; + testSession.evaluate(expected, loss); + } + }); + } + + @Test + public void testNoReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf, Reduction.NONE); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + Float[] expected = {10.733333f, 14.566667f}; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSumReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsoluteError instance = new MeanAbsoluteError(tf, Reduction.SUM); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + Float[] expected = {25.29999f}; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanAbsolutePercentageErrorTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanAbsolutePercentageErrorTest.java new file mode 100644 index 00000000000..7816a8a288a --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanAbsolutePercentageErrorTest.java @@ -0,0 +1,167 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class MeanAbsolutePercentageErrorTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class MeanAbsolutePercentageError. */ + @Test + public void testAllCorrectUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf); + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yTrue); + float expected = 0.0f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanAbsolutePercentageError. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 211.85184f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanAbsolutePercentageError. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 487.25922f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 422.8889f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf, Reduction.AUTO); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 694.4445f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testNoReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf, Reduction.NONE); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + Float[] expected = {621.8518f, 352.66666f}; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSumReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanAbsolutePercentageError instance = new MeanAbsolutePercentageError(tf, Reduction.SUM); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 974.51843f; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanSquaredErrorTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanSquaredErrorTest.java new file mode 100644 index 00000000000..1a971f0492b --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanSquaredErrorTest.java @@ -0,0 +1,194 @@ +/* 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.losses; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class MeanSquaredErrorTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class MeanSquaredError. */ + @Test + public void testAllCorrectUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf); + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yTrue); + float expected = 0.0f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanSquaredError. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 49.5f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanSquaredError. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 113.85f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 127.96667f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf, Reduction.AUTO); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = 97.833336f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testInvalidSampleWeight() { + for (TestSession.Mode tfMode : tfModes) + Assertions.assertThrows( + IllegalArgumentException.class, + () -> { + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 2))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 173.25f; + testSession.evaluate(expected, loss); + } + }); + } + + @Test + public void testNoReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf, Reduction.NONE); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + Float[] expected = {84.333336f, 143.36665f}; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSumReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredError instance = new MeanSquaredError(tf, Reduction.SUM); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + Float[] expected = {227.69998f}; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanSquaredLogarithmicErrorTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanSquaredLogarithmicErrorTest.java new file mode 100644 index 00000000000..558f9c84659 --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/MeanSquaredLogarithmicErrorTest.java @@ -0,0 +1,194 @@ +/* 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.losses; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class MeanSquaredLogarithmicErrorTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class MeanSquaredLogarithmicError. */ + @Test + public void testAllCorrectUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf); + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yTrue); + float expected = 0.0f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanSquaredLogarithmicError. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 1.4370421f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class MeanSquaredLogarithmicError. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 3.3051968f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 3.7856376f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf, Reduction.AUTO); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = 2.647374f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testInvalidSampleWeight() { + for (TestSession.Mode tfMode : tfModes) + Assertions.assertThrows( + IllegalArgumentException.class, + () -> { + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 2))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 83f / 6f; + testSession.evaluate(expected, loss); + } + }); + } + + @Test + public void testNoReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf, Reduction.NONE); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + Float[] expected = {2.3006392f, 4.3097544f}; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSumReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + MeanSquaredLogarithmicError instance = new MeanSquaredLogarithmicError(tf, Reduction.SUM); + float[] trueArray = {1f, 9f, 2f, -5f, -2f, 6f}; + float[] predArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + Float[] expected = {6.6103935f}; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/PoissonTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/PoissonTest.java new file mode 100644 index 00000000000..55c59ca5ac6 --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/PoissonTest.java @@ -0,0 +1,119 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +public class PoissonTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class Poisson. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Poisson instance = new Poisson(tf); + float[] predArray = {1f, 9f, 2f, 5f, 2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = -3.306581945521002f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class Poisson. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Poisson instance = new Poisson(tf); + float[] predArray = {1f, 9f, 2f, 5f, 2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = -7.605138474698304f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Poisson instance = new Poisson(tf); + float[] predArray = {1f, 9f, 2f, 5f, 2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {1.2f, 3.4f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = -6.147338926788071f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Poisson instance = new Poisson(tf); + float[] predArray = {1f, 9f, 2f, 5f, 2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + Poisson instance = new Poisson(tf, Reduction.AUTO); + float[] predArray = {1f, 9f, 2f, 5f, 2f, 6f}; + float[] trueArray = {4f, 8f, 12f, 8f, 1f, 3f}; + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 3, 1))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 3))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = -12.263126013890561f; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/SparseCategoricalCrossentropyTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/SparseCategoricalCrossentropyTest.java new file mode 100644 index 00000000000..a6a0ff35c78 --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/SparseCategoricalCrossentropyTest.java @@ -0,0 +1,225 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; +import org.tensorflow.types.TInt32; +import org.tensorflow.types.TInt64; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class SparseCategoricalCrossentropyTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class SparseCategoricalCrossentropy. */ + @Test + public void testAllCorrectUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + testSession.setEpsilon(1e-3f); + Ops tf = testSession.getTF(); + + int[] trueArray = {0, 1, 2}; + float[] predArray = { + 1.F, 0.F, 0.F, + 0.F, 1.F, 0.F, + 0.F, 0.F, 1.F + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 1))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + SparseCategoricalCrossentropy instance = new SparseCategoricalCrossentropy(tf); + Operand loss = instance.call(yTrue, yPred); + float expected = 0.0f; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 10.F, 0.F, 0.F, + 0.F, 10.F, 0.F, + 0.F, 0.F, 10.F + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new SparseCategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits); + testSession.evaluate(0.0f, loss); + } + } + + @Test + public void testInvalidPredictionsRange() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Class catchClass = + tfMode == TestSession.Mode.EAGER + ? IllegalArgumentException.class + : org.tensorflow.exceptions.TFInvalidArgumentException.class; + assertThrows( + catchClass, + () -> { + Ops tf = testSession.getTF(); + SparseCategoricalCrossentropy instance = new SparseCategoricalCrossentropy(tf); + int[] trueArray = {0, 1, 2}; + float[] predArray = { + 1.9f, .05f, .05f, + .5f, .89f, .6f, + .05f, .01f, .94f + }; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + Operand loss = instance.call(yTrue, yPred); + testSession.run(loss); + }); + } + } + + /** Test of call method, of class SparseCategoricalCrossentropy. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + SparseCategoricalCrossentropy instance = new SparseCategoricalCrossentropy(tf); + int[] trueArray = {0, 1, 2}; + float[] predArray = { + .9f, .05f, .05f, + .5f, .89f, .6f, + .05f, .01f, .94f + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 1))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + Operand loss = instance.call(yTrue, yPred); + float expected = 0.32396814f; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new SparseCategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits); + expected = 0.05737559f; + testSession.evaluate(expected, loss); + } + } + + /** Test of call method, of class SparseCategoricalCrossentropy. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + int[] trueArray = {0, 1, 2}; + float[] predArray = { + .9f, .05f, .05f, + .5f, .89f, .6f, + .05f, .01f, .94f + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 1))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + Operand sampleWeight = tf.constant(2.3f); + + SparseCategoricalCrossentropy instance = new SparseCategoricalCrossentropy(tf); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = .7451267f; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new SparseCategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits, sampleWeight); + expected = 0.13196386f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + SparseCategoricalCrossentropy instance = new SparseCategoricalCrossentropy(tf); + float[] sampleWeightArray = {1.2f, 3.4f, 5.6f}; + int[] trueArray = {0, 1, 2}; + float[] predArray = { + .9f, .05f, .05f, + .5f, .89f, .6f, + .05f, .01f, .94f + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 1))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(3, 3))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleWeightArray), tf.constant(Shape.of(3, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 1.0696f; + testSession.evaluate(expected, loss); + + // Test with logits. + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + instance = new SparseCategoricalCrossentropy(tf, true); + loss = instance.call(yTrue, logits, sampleWeight); + expected = 0.31829f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testNoReduction() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + + // Test with logits. + long[] trueArray = {0L, 1L, 2L}; + float[] logitsArray = { + 8.F, 1.F, 1.F, + 0.F, 9.F, 1.F, + 2.F, 3.F, 5.F + }; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(3, 1))); + Operand logits = + tf.reshape(tf.constant(logitsArray), tf.constant(Shape.of(3, 3))); + SparseCategoricalCrossentropy instance = + new SparseCategoricalCrossentropy(tf, true, Reduction.NONE); + Operand loss = instance.call(yTrue, logits); + Float[] expected = {0.001822f, 0.000459f, 0.169846f}; + testSession.evaluate(expected, loss); + } + } +} diff --git a/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/SquaredHingeTest.java b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/SquaredHingeTest.java new file mode 100644 index 00000000000..57a012bbe9d --- /dev/null +++ b/tensorflow-framework/src/test/java/org/tensorflow/framework/losses/SquaredHingeTest.java @@ -0,0 +1,146 @@ +/* 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.losses; + +import org.junit.jupiter.api.Test; +import org.tensorflow.Operand; +import org.tensorflow.framework.utils.TestSession; +import org.tensorflow.ndarray.Shape; +import org.tensorflow.op.Ops; +import org.tensorflow.types.TFloat32; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class SquaredHingeTest { + private final TestSession.Mode[] tfModes = {TestSession.Mode.EAGER, TestSession.Mode.GRAPH}; + + /** Test of call method, of class SquaredHinge. */ + @Test + public void testUnweighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + SquaredHinge instance = new SquaredHinge(tf); + float[] trueArray = {0, 1, 0, 1, 0, 0, 1, 1}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand loss = instance.call(yTrue, yPred); + float expected = 0.364062f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testInvalidLabelValue() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Class catchClass = + tfMode == TestSession.Mode.EAGER + ? IllegalArgumentException.class + : org.tensorflow.exceptions.TFInvalidArgumentException.class; + assertThrows( + catchClass, + () -> { + Ops tf = testSession.getTF(); + SquaredHinge instance = new SquaredHinge(tf); + float[] trueArray = {0, 2, 0, 1, 0, 0, 1, 1}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand loss = instance.call(yTrue, yPred); + testSession.run(loss); + }); + } + } + + /** Test of call method, of class SquaredHinge. */ + @Test + public void testScalarWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + SquaredHinge instance = new SquaredHinge(tf); + float[] trueArray = {0, 1, 0, 1, 0, 0, 1, 1}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand sampleWeight = tf.constant(2.3f); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0.8373437f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testSampleWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + SquaredHinge instance = new SquaredHinge(tf); + float[] sampleArray = {1.2f, 3.4f}; + float[] trueArray = {0, 1, 0, 1, 0, 0, 1, 1}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 1))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0.7043125f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testZeroWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + SquaredHinge instance = new SquaredHinge(tf); + float[] trueArray = {0, 1, 0, 1, 0, 0, 1, 1}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4))); + Operand yPred = tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4))); + Operand sampleWeight = tf.constant(0.F); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + float expected = 0f; + testSession.evaluate(expected, loss); + } + } + + @Test + public void testTimestepWeighted() { + for (TestSession.Mode tfMode : tfModes) + try (TestSession testSession = TestSession.createTestSession(tfMode)) { + Ops tf = testSession.getTF(); + SquaredHinge instance = new SquaredHinge(tf, Reduction.AUTO); + float[] trueArray = {0, 1, 0, 1, 0, 0, 1, 1}; + float[] predArray = {-0.3f, 0.2f, -0.1f, 1.6f, -0.25f, -1.f, 0.5f, 0.6f}; + Operand yTrue = + tf.reshape(tf.constant(trueArray), tf.constant(Shape.of(2, 4, 1))); + Operand yPred = + tf.reshape(tf.constant(predArray), tf.constant(Shape.of(2, 4, 1))); + float[] sampleArray = {3f, 6f, 5f, 0f, 4f, 2f, 1f, 3f}; + Operand sampleWeight = + tf.reshape(tf.constant(sampleArray), tf.constant(Shape.of(2, 4))); + Operand loss = instance.call(yTrue, yPred, sampleWeight); + + float expected = 1.54250000f; + testSession.evaluate(expected, loss); + } + } +}