/**

* @license

* Copyright 2018 Google LLC

*

* Use of this source code is governed by an MIT-style

* license that can be found in the LICENSE file or at

* https://opensource.org/licenses/MIT.

* =============================================================================

*/

import {Tensor} from '@tensorflow/tfjs-core';

import * as losses from './losses';

import * as metrics from './metrics';

/**

* Binary accuracy metric function.

*

* `yTrue` and `yPred` can have 0-1 values. Example:

* ```js

* const x = tf.tensor2d([[1, 1, 1, 1], [0, 0, 0, 0]], [2, 4]);

* const y = tf.tensor2d([[1, 0, 1, 0], [0, 0, 0, 1]], [2, 4]);

* const accuracy = tf.metrics.binaryAccuracy(x, y);

* accuracy.print();

* ```

*

* `yTrue` and `yPred` can also have floating-number values between 0 and 1, in

* which case the values will be thresholded at 0.5 to yield 0-1 values (i.e.,

* a value >= 0.5 and <= 1.0 is interpreted as 1).

*

* Example:

* ```js

* const x = tf.tensor1d([1, 1, 1, 1, 0, 0, 0, 0]);

* const y = tf.tensor1d([0.2, 0.4, 0.6, 0.8, 0.2, 0.3, 0.4, 0.7]);

* const accuracy = tf.metrics.binaryAccuracy(x, y);

* accuracy.print();

* ```

*

* @param yTrue Binary Tensor of truth.

* @param yPred Binary Tensor of prediction.

* @return Accuracy Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function binaryAccuracy(yTrue: Tensor, yPred: Tensor): Tensor {

return metrics.binaryAccuracy(yTrue, yPred);

}

/**

* Binary crossentropy metric function.

*

* Example:

* ```js

* const x = tf.tensor2d([[0], [1], [1], [1]]);

* const y = tf.tensor2d([[0], [0], [0.5], [1]]);

* const crossentropy = tf.metrics.binaryCrossentropy(x, y);

* crossentropy.print();

* ```

*

* @param yTrue Binary Tensor of truth.

* @param yPred Binary Tensor of prediction, probabilities for the `1` case.

* @return Accuracy Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function binaryCrossentropy(yTrue: Tensor, yPred: Tensor): Tensor {

return metrics.binaryCrossentropy(yTrue, yPred);

}

/**

* Sparse categorical accuracy metric function.

*

* Example:

* ```js

*

* const yTrue = tf.tensor1d([1, 1, 2, 2, 0]);

* const yPred = tf.tensor2d(

* [[0, 1, 0], [1, 0, 0], [0, 0.4, 0.6], [0, 0.6, 0.4], [0.7, 0.3, 0]]);

* const crossentropy = tf.metrics.sparseCategoricalAccuracy(yTrue, yPred);

* crossentropy.print();

* ```

*

* @param yTrue True labels: indices.

* @param yPred Predicted probabilities or logits.

* @returns Accuracy tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function sparseCategoricalAccuracy(

yTrue: Tensor, yPred: Tensor): Tensor {

return metrics.sparseCategoricalAccuracy(yTrue, yPred);

}

/**

* Categorical accuracy metric function.

*

* Example:

* ```js

* const x = tf.tensor2d([[0, 0, 0, 1], [0, 0, 0, 1]]);

* const y = tf.tensor2d([[0.1, 0.8, 0.05, 0.05], [0.1, 0.05, 0.05, 0.8]]);

* const accuracy = tf.metrics.categoricalAccuracy(x, y);

* accuracy.print();

* ```

*

* @param yTrue Binary Tensor of truth: one-hot encoding of categories.

* @param yPred Binary Tensor of prediction: probabilities or logits for the

* same categories as in `yTrue`.

* @return Accuracy Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function categoricalAccuracy(yTrue: Tensor, yPred: Tensor): Tensor {

return metrics.categoricalAccuracy(yTrue, yPred);

}

/**

* Categorical crossentropy between an output tensor and a target tensor.

*

* @param target A tensor of the same shape as `output`.

* @param output A tensor resulting from a softmax (unless `fromLogits` is

* `true`, in which case `output` is expected to be the logits).

* @param fromLogits Boolean, whether `output` is the result of a softmax, or is

* a tensor of logits.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function categoricalCrossentropy(yTrue: Tensor, yPred: Tensor): Tensor {

return metrics.categoricalCrossentropy(yTrue, yPred);

}

/**

* Computes the precision of the predictions with respect to the labels.

*

* Example:

* ```js

* const x = tf.tensor2d(

* [

* [0, 0, 0, 1],

* [0, 1, 0, 0],

* [0, 0, 0, 1],

* [1, 0, 0, 0],

* [0, 0, 1, 0]

* ]

* );

*

* const y = tf.tensor2d(

* [

* [0, 0, 1, 0],

* [0, 1, 0, 0],

* [0, 0, 0, 1],

* [0, 1, 0, 0],

* [0, 1, 0, 0]

* ]

* );

*

* const precision = tf.metrics.precision(x, y);

* precision.print();

* ```

*

* @param yTrue The ground truth values. Expected to contain only 0-1 values.

* @param yPred The predicted values. Expected to contain only 0-1 values.

* @return Precision Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function precision(yTrue: Tensor, yPred: Tensor): Tensor {

return metrics.precision(yTrue, yPred);

}

/**

* Computes the recall of the predictions with respect to the labels.

*

* Example:

* ```js

* const x = tf.tensor2d(

* [

* [0, 0, 0, 1],

* [0, 1, 0, 0],

* [0, 0, 0, 1],

* [1, 0, 0, 0],

* [0, 0, 1, 0]

* ]

* );

*

* const y = tf.tensor2d(

* [

* [0, 0, 1, 0],

* [0, 1, 0, 0],

* [0, 0, 0, 1],

* [0, 1, 0, 0],

* [0, 1, 0, 0]

* ]

* );

*

* const recall = tf.metrics.recall(x, y);

* recall.print();

* ```

*

* @param yTrue The ground truth values. Expected to contain only 0-1 values.

* @param yPred The predicted values. Expected to contain only 0-1 values.

* @return Recall Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function recall(yTrue: Tensor, yPred: Tensor): Tensor {

return metrics.recall(yTrue, yPred);

}

/**

* Loss or metric function: Cosine proximity.

*

* Mathematically, cosine proximity is defined as:

* `-sum(l2Normalize(yTrue) * l2Normalize(yPred))`,

* wherein `l2Normalize()` normalizes the L2 norm of the input to 1 and `*`

* represents element-wise multiplication.

*

* ```js

* const yTrue = tf.tensor2d([[1, 0], [1, 0]]);

* const yPred = tf.tensor2d([[1 / Math.sqrt(2), 1 / Math.sqrt(2)], [0, 1]]);

* const proximity = tf.metrics.cosineProximity(yTrue, yPred);

* proximity.print();

* ```

*

* @param yTrue Truth Tensor.

* @param yPred Prediction Tensor.

* @return Cosine proximity Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function cosineProximity(yTrue: Tensor, yPred: Tensor): Tensor {

return losses.cosineProximity(yTrue, yPred);

}

/**

* Loss or metric function: Mean absolute error.

*

* Mathematically, mean absolute error is defined as:

* `mean(abs(yPred - yTrue))`,

* wherein the `mean` is applied over feature dimensions.

*

* ```js

* const yTrue = tf.tensor2d([[0, 1], [0, 0], [2, 3]]);

* const yPred = tf.tensor2d([[0, 1], [0, 1], [-2, -3]]);

* const mse = tf.metrics.meanAbsoluteError(yTrue, yPred);

* mse.print();

* ```

*

* @param yTrue Truth Tensor.

* @param yPred Prediction Tensor.

* @return Mean absolute error Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function meanAbsoluteError(yTrue: Tensor, yPred: Tensor): Tensor {

return losses.meanAbsoluteError(yTrue, yPred);

}

/**

* Loss or metric function: Mean absolute percentage error.

*

* ```js

* const yTrue = tf.tensor2d([[0, 1], [10, 20]]);

* const yPred = tf.tensor2d([[0, 1], [11, 24]]);

* const mse = tf.metrics.meanAbsolutePercentageError(yTrue, yPred);

* mse.print();

* ```

*

* Aliases: `tf.metrics.MAPE`, `tf.metrics.mape`.

*

* @param yTrue Truth Tensor.

* @param yPred Prediction Tensor.

* @return Mean absolute percentage error Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function meanAbsolutePercentageError(

yTrue: Tensor, yPred: Tensor): Tensor {

return losses.meanAbsolutePercentageError(yTrue, yPred);

}

export function MAPE(yTrue: Tensor, yPred: Tensor): Tensor {

return losses.meanAbsolutePercentageError(yTrue, yPred);

}

export function mape(yTrue: Tensor, yPred: Tensor): Tensor {

return losses.meanAbsolutePercentageError(yTrue, yPred);

}

/**

* Loss or metric function: Mean squared error.

*

* ```js

* const yTrue = tf.tensor2d([[0, 1], [3, 4]]);

* const yPred = tf.tensor2d([[0, 1], [-3, -4]]);

* const mse = tf.metrics.meanSquaredError(yTrue, yPred);

* mse.print();

* ```

*

* Aliases: `tf.metrics.MSE`, `tf.metrics.mse`.

*

* @param yTrue Truth Tensor.

* @param yPred Prediction Tensor.

* @return Mean squared error Tensor.

*

* @doc {heading: 'Metrics', namespace: 'metrics'}

*/

export function meanSquaredError(yTrue: Tensor, yPred: Tensor): Tensor {

return losses.meanSquaredError(yTrue, yPred);

}

export function MSE(yTrue: Tensor, yPred: Tensor): Tensor {

return losses.meanSquaredError(yTrue, yPred);

}

export function mse(yTrue: Tensor, yPred: Tensor): Tensor {

return losses.meanSquaredError(yTrue, yPred);

}