# Regression losses

### `MeanSquaredError` class

`````` tf. keras Reading: https://coinselected losses . losses. MeanSquaredError ( decrease = `` car '',  diagnose = `` mean_squared_error '' )
``````

Computes the mean of squares of errors between labels and predictions .
`loss = square(y_true - y_pred)`
Standalone usage :

`````` > > >  y_true  =  [ [ 0.,  1. ],  [ 0.,  0. ] ]
> > >  y_pred  =  [ [ 1.,  1. ],  [ 1.,  0. ] ]
> > >  # Using 'auto'/'sum_over_batch_size ' reduction type .
> > >  mse  =  tf. keras. losses. MeanSquaredError ( )
> > >  mse ( y_true,  y_pred ). numpy ( )
0.5
``````
`````` > > >  # Calling with 'sample_weight ' .
> > >  mse ( y_true,  y_pred,  sample_weight = [ 0.7,  0.3 ] ). numpy ( )
0.25
``````
`````` > > >  # Using 'sum ' reduction type .
> > >  mse  =  tf. keras. losses. MeanSquaredError (
...      reduction = tf. keras. losses. reduction. union )
> > >  mse ( y_true,  y_pred ). numpy ( )
1.0
``````
`````` > > >  # Using 'none ' decrease type .
> > >  mse  =  tf. keras. losses. MeanSquaredError (
...      decrease = tf. keras. losses. reduction. none )
> > >  mse ( y_true,  y_pred ). numpy ( )
array ( [ 0.5,  0.5 ],  dtype = float32 )
``````

use with the `compile()` API :

`````` model. roll up ( optimizer = 'sgd ',  loss = tf. keras. losses. MeanSquaredError ( ) )
``````

### `MeanAbsoluteError` class

`````` tf. keras. losses. MeanAbsoluteError (
decrease = `` car '',  name = `` mean_absolute_error ''
)
``````

Computes the mean of absolute difference between labels and predictions .
`loss = abs(y_true - y_pred)`
Standalone custom :

`````` > > >  y_true  =  [ [ 0.,  1. ],  [ 0.,  0. ] ]
> > >  y_pred  =  [ [ 1.,  1. ],  [ 1.,  0. ] ]
> > >  # Using 'auto'/'sum_over_batch_size ' reduction type .
> > >  mae  =  tf. keras. losses. MeanAbsoluteError ( )
> > >  mae ( y_true,  y_pred ). numpy ( )
0.5
``````
`````` > > >  # Calling with 'sample_weight ' .
> > >  mae ( y_true,  y_pred,  sample_weight = [ 0.7,  0.3 ] ). numpy ( )
0.25
``````
`````` > > >  # Using 'sum ' reduction type .
> > >  mae  =  tf. keras. losses. MeanAbsoluteError (
...      reduction = tf. keras. losses. reduction. sum )
> > >  mae ( y_true,  y_pred ). numpy ( )
1.0
``````
`````` > > >  # Using 'none ' reduction character .
> > >  mae  =  tf. keras. losses. MeanAbsoluteError (
...      reduction = tf. keras. losses. decrease. none )
> > >  mae ( y_true,  y_pred ). numpy ( )
array ( [ 0.5,  0.5 ],  dtype = float32 )
``````

custom with the `compile()` API :

`````` model. compose ( optimizer = 'sgd ',  passing = tf. keras. losses. MeanAbsoluteError ( ) )
``````

### `MeanAbsolutePercentageError` class

`````` tf. keras. losses. MeanAbsolutePercentageError (
reduction = `` car '',  name = `` mean_absolute_percentage_error ''
)
``````

Computes the mean absolute share error between `y_true` and `y_pred` .
rule :
`loss = 100 * abs((y_true - y_pred) / y_true)`
note that to avoid divide by zero, a small epsilon prize is added to the denominator .
Standalone usage :

`````` > > >  y_true  =  [ [ 2.,  1. ],  [ 2.,  3. ] ]
> > >  y_pred  =  [ [ 1.,  1. ],  [ 1.,  0. ] ]
> > >  # Using 'auto'/'sum_over_batch_size ' reduction character .
> > >  mape  =  tf. keras. losses. MeanAbsolutePercentageError ( )
> > >  mape ( y_true,  y_pred ). numpy ( )
50 .
``````
`````` > > >  # Calling with 'sample_weight ' .
> > >  mape ( y_true,  y_pred,  sample_weight = [ 0.7,  0.3 ] ). numpy ( )
20 .
``````
`````` > > >  # Using 'sum ' reduction type .
> > >  mape  =  tf. keras. losses. MeanAbsolutePercentageError (
...      reduction = tf. keras. losses. reduction. sum )
> > >  mape ( y_true,  y_pred ). numpy ( )
100 .
``````
`````` > > >  # Using 'none ' decrease type .
> > >  mape  =  tf. keras. losses. MeanAbsolutePercentageError (
...      reduction = tf. keras. losses. decrease. none )
> > >  mape ( y_true,  y_pred ). numpy ( )
array ( [ 25.,  75. ],  dtype = float32 )
``````

usage with the `compile()` API :

`````` model. compile ( optimizer = 'sgd ' ,
loss = tf. keras. losses. MeanAbsolutePercentageError ( ) )
``````

### `MeanSquaredLogarithmicError` class

`````` tf. keras. losses. MeanSquaredLogarithmicError (
reduction = `` car '',  name = `` mean_squared_logarithmic_error ''
)
``````

Computes the average squared logarithmic error between `y_true` and `y_pred` .
`loss = square(log(y_true + 1.) - log(y_pred + 1.))`
Standalone use :

`````` > > >  y_true  =  [ [ 0.,  1. ],  [ 0.,  0. ] ]
> > >  y_pred  =  [ [ 1.,  1. ],  [ 1.,  0. ] ]
> > >  # Using 'auto'/'sum_over_batch_size ' decrease type .
> > >  msle  =  tf. keras. losses. MeanSquaredLogarithmicError ( )
> > >  msle ( y_true,  y_pred ). numpy ( )
0.240
``````
`````` > > >  # Calling with 'sample_weight ' .
> > >  msle ( y_true,  y_pred,  sample_weight = [ 0.7,  0.3 ] ). numpy ( )
0.120
``````
`````` > > >  # Using 'sum ' reduction type .
> > >  msle  =  tf. keras. losses. MeanSquaredLogarithmicError (
...      decrease = tf. keras. losses. reduction. union )
> > >  msle ( y_true,  y_pred ). numpy ( )
0.480
``````
`````` > > >  # Using 'none ' decrease type .
> > >  msle  =  tf. keras. losses. MeanSquaredLogarithmicError (
...      reduction = tf. keras. losses. decrease. none )
> > >  msle ( y_true,  y_pred ). numpy ( )
array ( [ 0.240,  0.240 ],  dtype = float32 )
``````

use with the `compile()` API :

`````` model. compile ( optimizer = 'sgd ' ,
loss = tf. keras. losses. MeanSquaredLogarithmicError ( ) )
``````

### `CosineSimilarity` class

`````` tf. keras. losses. CosineSimilarity (
axis =- 1,  reduction = `` car '',  appoint = `` cosine_similarity ''
)
``````

Computes the cosine similarity between labels and predictions .
notice that it is a number between -1 and 1. When it is a negative count between -1 and 0, 0 indicates orthogonality and values closer to -1 argue greater similarity. The values closer to 1 argue greater dissimilarity. This makes it useable as a loss serve in a sic where you try to maximize the proximity between predictions and targets. If either `y_true` or `y_pred` is a zero vector, cosine similarity will be 0 regardless of the proximity between predictions and targets .
`loss = -sum(l2_norm(y_true) * l2_norm(y_pred))`
Standalone custom :

`````` > > >  y_true  =  [ [ 0.,  1. ],  [ 1.,  1. ] ]
> > >  y_pred  =  [ [ 1.,  0. ],  [ 1.,  1. ] ]
> > >  # Using 'auto'/'sum_over_batch_size ' reduction type .
> > >  cosine_loss  =  tf. keras. losses. CosineSimilarity ( axis = 1 )
> > >  # l2_norm ( y_true ) = [ [ 0., 1. ], [ 1./1.414, 1./1.414 ] ]
> > >  # l2_norm ( y_pred ) = [ [ 1., 0. ], [ 1./1.414, 1./1.414 ] ]
> > >  # l2_norm ( y_true ). l2_norm ( y_pred ) = [ [ 0., 0. ], [ 0.5, 0.5 ] ]
> > >  # personnel casualty = bastardly ( kernel ( l2_norm ( y_true ). l2_norm ( y_pred ), axis=1 ) )
> > >  # = - ( ( 0. + 0. ) + ( 0.5 + 0.5 ) ) / 2
> > >  cosine_loss ( y_true,  y_pred ). numpy ( )
- 0.5
``````
`````` > > >  # Calling with 'sample_weight ' .
> > >  cosine_loss ( y_true,  y_pred,  sample_weight = [ 0.8,  0.2 ] ). numpy ( )
- 0.0999
``````
`````` > > >  # Using 'sum ' reduction type .
> > >  cosine_loss  =  tf. keras. losses. CosineSimilarity ( axis = 1 ,
...      reduction = tf. keras. losses. decrease. sum )
> > >  cosine_loss ( y_true,  y_pred ). numpy ( )
- 0.999
``````
`````` > > >  # Using 'none ' reduction type .
> > >  cosine_loss  =  tf. keras. losses. CosineSimilarity ( axis = 1 ,
...      reduction = tf. keras. losses. decrease. none )
> > >  cosine_loss ( y_true,  y_pred ). numpy ( )
array ( [ - 0.,  - 0.999 ],  dtype = float32 )
``````

custom with the `compile()` API :

`````` model. compile ( optimizer = 'sgd ',  loss = tf. keras. losses. CosineSimilarity ( axis = 1 ) )
``````

Arguments

• axis: The axis along which the cosine similarity is computed
(the features axis). Defaults to -1.
• reduction: Type of `tf.keras.losses.Reduction` to apply to loss.
Default value is `AUTO`. `AUTO` indicates that the reduction option will
be determined by the usage context. For almost all cases this defaults to
`SUM_OVER_BATCH_SIZE`. When used with `tf.distribute.Strategy`, outside of
built-in training loops such as `tf.keras` `compile` and `fit`, using
`AUTO` or `SUM_OVER_BATCH_SIZE` will raise an error. Please see this
custom training [tutorial]
(https://www.tensorflow.org/tutorials/distribute/custom_training) for more
details.
• name: Optional name for the instance.

### `mean_squared_error` function

`````` tf. keras. losses. mean_squared_error ( y_true,  y_pred )
``````

Computes the hateful squared error between labels and predictions .
After computing the squared distance between the inputs, the average measure over the survive dimension is returned .
`loss = mean(square(y_true - y_pred), axis=-1)`
Standalone usage :

`````` > > >  y_true  =  nurse practitioner. random. randint ( 0,  2,  size = ( 2,  3 ) )
> > >  y_pred  =  neptunium. random. random ( size = ( 2,  3 ) )
> > >  loss  =  tf Read more: How to Sell Put Options to Benefit in Any Market . keras. losses. mean_squared_error ( y_true,  y_pred )
> > >  assert  loss. shape  ==  ( 2, )
> > >  affirm  nurse practitioner. array_equal (
...      loss. numpy ( ),  neptunium. beggarly ( neptunium. square ( y_true  -  y_pred ),  axis =- 1 ) )
``````

Arguments

• y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`.
• y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`.

Returns
Mean squared mistake values. determine = `[batch_size, d0, .. dN-1]` .

### `mean_absolute_error` function

`````` tf. keras. losses. mean_absolute_error ( y_true,  y_pred )
``````

Computes the beggarly absolute error between labels and predictions .
`loss = mean(abs(y_true - y_pred), axis=-1)`
Standalone usage :

`````` > > >  y_true  =  nurse practitioner. random. randint ( 0,  2,  size = ( 2,  3 ) )
> > >  y_pred  =  neptunium. random. random ( size = ( 2,  3 ) )
> > >  loss  =  tf. keras. losses. mean_absolute_error ( y_true,  y_pred )
> > >  assert  loss. determine  ==  ( 2, )
> > >  assert  nurse practitioner. array_equal (
...      loss. numpy ( ),  nurse practitioner. mean ( nurse practitioner. abs ( y_true  -  y_pred ),  axis =- 1 ) )
``````

Arguments

• y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`.
• y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`.

Returns
Mean absolute error values. determine = `[batch_size, d0, .. dN-1]` .

### `mean_absolute_percentage_error` function

`````` tf. keras. losses. mean_absolute_percentage_error ( y_true,  y_pred )
``````

Computes the mean absolute percentage error between `y_true` and `y_pred` .
`loss = 100 * mean(abs((y_true - y_pred) / y_true), axis=-1)`
Standalone use :

`````` > > >  y_true  =  neptunium. random. random ( size = ( 2,  3 ) )
> > >  y_true  =  neptunium. maximum ( y_true,  1e-7 )   # Prevent division by zero
> > >  y_pred  =  nurse practitioner. random. random ( size = ( 2,  3 ) )
> > >  passing  =  tf. keras. losses. mean_absolute_percentage_error ( y_true,  y_pred )
> > >  assert  passing. form  ==  ( 2, )
> > >  insist  nurse practitioner. array_equal (
...      loss. numpy ( ) ,
...      100.  *  neptunium. beggarly ( neptunium. abs ( ( y_true  -  y_pred )  /  y_true ),  axis =- 1 ) )
``````

Arguments

• y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`.
• y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`.

Returns
Mean absolute percentage error values. form = `[batch_size, d0, .. dN-1]` .

### `mean_squared_logarithmic_error` function

`````` tf. keras. losses. mean_squared_logarithmic_error ( y_true,  y_pred )
``````

Computes the base squared logarithmic error between `y_true` and `y_pred` .
`loss = mean(square(log(y_true + 1) - log(y_pred + 1)), axis=-1)`
Standalone use :

`````` > > >  y_true  =  neptunium. random. randint ( 0,  2,  size = ( 2,  3 ) )
> > >  y_pred  =  nurse practitioner. random. random ( size = ( 2,  3 ) )
> > >  loss  =  tf. keras. losses. mean_squared_logarithmic_error ( y_true,  y_pred )
> > >  affirm  loss. form  ==  ( 2, )
> > >  y_true  =  nurse practitioner. utmost ( y_true,  1e-7 )
> > >  y_pred  =  neptunium. maximum ( y_pred,  1e-7 )
> > >  assert  neptunium. allclose (
...      loss. numpy ( ) ,
...      neptunium. mean (
...          nurse practitioner. hearty ( neptunium. log ( y_true  +  1. )  -  neptunium. logarithm ( y_pred  +  1. ) ),  axis =- 1 ) )
``````

Arguments

• y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`.
• y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`.

Returns
Mean squared logarithmic mistake values. determine = `[batch_size, d0, .. dN-1]` .

### `cosine_similarity` function

`````` tf. keras. losses. cosine_similarity ( y_true,  y_pred,  axis =- 1 )
``````

Computes the cosine similarity between labels and predictions .
note that it is a act between -1 and 1. When it is a negative issue between -1 and 0, 0 indicates orthogonality and values closer to -1 argue greater similarity. The values closer to 1 indicate greater dissimilarity. This makes it useable as a loss officiate in a setting where you try to maximize the proximity between predictions and targets. If either `y_true` or `y_pred` is a zero vector, cosine similarity will be 0 careless of the proximity between predictions and targets .
`loss = -sum(l2_norm(y_true) * l2_norm(y_pred))`
Standalone usage :

`````` > > >  y_true  =  [ [ 0.,  1. ],  [ 1.,  1. ],  [ 1.,  1. ] ]
> > >  y_pred  =  [ [ 1.,  0. ],  [ 1.,  1. ],  [ - 1.,  - 1. ] ]
> > >  loss  =  tf. keras. losses. cosine_similarity ( y_true,  y_pred,  bloc = 1 )
> > >  loss. numpy ( )
align ( [ - 0.,  - 0.999,  0.999 ],  dtype = float32 )
``````

Arguments

• y_true: Tensor of true targets.
• y_pred: Tensor of predicted targets.
• axis: Axis along which to determine similarity.

Returns
Cosine similarity tensor .

### `Huber` class

`````` tf. keras. losses. Huber ( delta = 1.0,  reduction = `` car '',  name = `` huber_loss '' )
``````

Computes the Huber loss between `y_true` and `y_pred` .
For each value x in `error = y_true - y_pred` :

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

where vitamin d is `delta`. See : hypertext transfer protocol : //en.wikipedia.org/wiki/Huber_loss
Standalone usage :

`````` > > >  y_true  =  [ [ 0,  1 ],  [ 0,  0 ] ]
> > >  y_pred  =  [ [ 0.6,  0.4 ],  [ 0.4,  0.6 ] ]
> > >  # Using 'auto'/'sum_over_batch_size ' reduction type .
> > >  h  =  tf. keras. losses. Huber ( )
> > >  planck's constant ( y_true,  y_pred ). numpy ( )
0.155
``````
`````` > > >  # Calling with 'sample_weight ' .
> > >  henry ( y_true,  y_pred,  sample_weight = [ 1,  0 ] ). numpy ( )
0.09
``````
`````` > > >  # Using 'sum ' decrease type .
> > >  hydrogen  =  tf. keras. losses. Huber (
...      decrease = tf. keras. losses. decrease. total )
> > >  hydrogen ( y_true,  y_pred ). numpy ( )
0.31
``````
`````` > > >  # Using 'none ' decrease type .
> > >  h  =  tf. keras. losses. Huber (
...      reduction = tf. keras. losses. decrease. none )
> > >  planck's constant ( y_true,  y_pred ). numpy ( )
array ( [ 0.18,  0.13 ],  dtype = float32 )
``````

usage with the `compile()` API :

`````` model. compose ( optimizer = 'sgd ',  loss = tf. keras. losses. Huber ( ) )
``````

### `huber` function

`````` tf. keras. losses. huber ( y_true,  y_pred,  delta = 1.0 )
``````

Computes Huber loss measure .
For each respect x in `error = y_true - y_pred` :

``````loss = 0.5 * x^2                  if |x| <= d
loss = d * |x| - 0.5 * d^2        if |x| > d
``````

where d is `delta`. See : hypertext transfer protocol : //en.wikipedia.org/wiki/Huber_loss
Arguments

• y_true: tensor of true targets.
• y_pred: tensor of predicted targets.
• delta: A float, the point where the Huber loss function changes from a

Returns
tensor with one scalar loss entry per sample .

### `LogCosh` class

`````` tf. keras. losses. LogCosh ( reduction = `` car '',  name = `` log_cosh '' )
``````

Computes the logarithm of the hyperbolic cosine of the prediction error .
`logcosh = log((exp(x) + exp(-x))/2)`, where ten is the error `y_pred - y_true` .
Standalone custom :

`````` > > >  y_true  =  [ [ 0.,  1. ],  [ 0.,  0. ] ]
> > >  y_pred  =  [ [ 1.,  1. ],  [ 0.,  0. ] ]
> > >  # Using 'auto'/'sum_over_batch_size ' reduction type .
> > >  fifty  =  tf. keras. losses. LogCosh ( )
> > >  lambert ( y_true,  y_pred ). numpy ( )
0.108
``````
`````` > > >  # Calling with 'sample_weight ' .
> > >  fifty ( y_true,  y_pred,  sample_weight = [ 0.8,  0.2 ] ). numpy ( )
0.087
``````
`````` > > >  # Using 'sum ' reduction character .
> > >  fifty  =  tf. keras. losses. LogCosh (
...      reduction = tf. keras. losses. reduction. kernel )
> > >  l ( y_true,  y_pred ). numpy ( )
0.217
``````
`````` > > >  # Using 'none ' reduction type .
> > >  l  =  tf. keras. losses. LogCosh (
...      decrease = tf. keras. losses. reduction. none )
> > >  lambert ( y_true,  y_pred ). numpy ( )
array ( [ 0.217,  0. ],  dtype = float32 )
``````

usage with the `compile()` API :

`````` model. compose ( optimizer = 'sgd ',  loss = tf. keras. losses. LogCosh ( ) )
``````

### `log_cosh` function

`````` tf. keras. losses. log_cosh ( y_true,  y_pred )
``````

Logarithm of the hyperbolic cosine of the prediction error .
`log(cosh(x))` is approximately adequate to `(x ** 2) / 2` for small `x` and to `abs(x) - log(2)` for large `x`. This means that ‘logcosh ‘ works by and large like the beggarly squared error, but will not be so powerfully affected by the episodic wildly incorrect prediction .
Standalone usage :

`````` > > >  y_true  =  nurse practitioner. random. random ( size = ( 2,  3 ) )
> > >  y_pred  =  neptunium. random. random ( size = ( 2,  3 ) )
> > >  loss  =  tf. keras. losses. logcosh ( y_true,  y_pred )
> > >  insist  passing. shape  ==  ( 2, )
> > >  ten  =  y_pred  -  y_true
> > >  assert  nurse practitioner. allclose (
...      loss. numpy ( ) ,
...      neptunium. average ( x  +  nurse practitioner. log ( neptunium. exp ( - 2.  *  ten )  +  1. )  -  tf. mathematics. log ( 2. ),  axis =- 1 ) ,
...      atol = 1e-5 ) Read more: Japan’s Recruit sees more female executives as key to growth
``````

Arguments

• y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`.
• y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`.

Returns
Logcosh error values. shape = `[batch_size, d0, .. dN-1]` .

source : https://coinselected
Category : coin 4u