content: 
  
  
  __all__ = ['mae', 'mse', 'rmse', 'mape', 'smape', 'mase', 'rmae', 'quantile_loss', 'mqloss']
  
  
  from typing import Optional, Union
  
  import numpy as np
  
  
  def _divide_no_nan(a: np.ndarray, b: np.ndarray) -> np.ndarray:
      """
      Auxiliary funtion to handle divide by 0
      """
      div = a / b
      div[div != div] = 0.0
      div[div == float("inf")] = 0.0
      return div
  
  
  def _metric_protections(
      y: np.ndarray, y_hat: np.ndarray, weights: Optional[np.ndarray]
  ) -> None:
      assert (weights is None) or (np.sum(weights) > 0), "Sum of weights cannot be 0"
      assert (weights is None) or (
          weights.shape == y.shape
      ), f"Wrong weight dimension weights.shape {weights.shape}, y.shape {y.shape}"
  
  
  def mae(
      y: np.ndarray,
      y_hat: np.ndarray,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Mean Absolute Error
  
      Calculates Mean Absolute Error between
      `y` and `y_hat`. MAE measures the relative prediction
      accuracy of a forecasting method by calculating the
      deviation of the prediction and the true
      value at a given time and averages these devations
      over the length of the series.
  
      ```math
      \mathrm{MAE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} |y_{\tau} - \hat{y}_{\tau}|
      ```
  
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: MAE.
      """
      _metric_protections(y, y_hat, weights)
  
      delta_y = np.abs(y - y_hat)
      if weights is not None:
          mae = np.average(
              delta_y[~np.isnan(delta_y)], weights=weights[~np.isnan(delta_y)], axis=axis
          )
      else:
          mae = np.nanmean(delta_y, axis=axis)
  
      return mae
  
  
  def mse(
      y: np.ndarray,
      y_hat: np.ndarray,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Mean Squared Error
  
      Calculates Mean Squared Error between
      `y` and `y_hat`. MSE measures the relative prediction
      accuracy of a forecasting method by calculating the
      squared deviation of the prediction and the true
      value at a given time, and averages these devations
      over the length of the series.
  
      ```math
      \mathrm{MSE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} (y_{\tau} - \hat{y}_{\tau})^{2}
      ```
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: MSE.
      """
      _metric_protections(y, y_hat, weights)
  
      delta_y = np.square(y - y_hat)
      if weights is not None:
          mse = np.average(
              delta_y[~np.isnan(delta_y)], weights=weights[~np.isnan(delta_y)], axis=axis
          )
      else:
          mse = np.nanmean(delta_y, axis=axis)
  
      return mse
  
  
  def rmse(
      y: np.ndarray,
      y_hat: np.ndarray,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Root Mean Squared Error
  
      Calculates Root Mean Squared Error between
      `y` and `y_hat`. RMSE measures the relative prediction
      accuracy of a forecasting method by calculating the squared deviation
      of the prediction and the observed value at a given time and
      averages these devations over the length of the series.
      Finally the RMSE will be in the same scale
      as the original time series so its comparison with other
      series is possible only if they share a common scale.
      RMSE has a direct connection to the L2 norm.
  
      ```math
      \mathrm{RMSE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \sqrt{\frac{1}{H} \sum^{t+H}_{\tau=t+1} (y_{\tau} - \hat{y}_{\tau})^{2}}
      ```
  
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: RMSE.
      """
      return np.sqrt(mse(y, y_hat, weights, axis))
  
  
  def mape(
      y: np.ndarray,
      y_hat: np.ndarray,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Mean Absolute Percentage Error
  
      Calculates Mean Absolute Percentage Error  between
      `y` and `y_hat`. MAPE measures the relative prediction
      accuracy of a forecasting method by calculating the percentual deviation
      of the prediction and the observed value at a given time and
      averages these devations over the length of the series.
      The closer to zero an observed value is, the higher penalty MAPE loss
      assigns to the corresponding error.
  
      ```math
      \mathrm{MAPE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \frac{|y_{\tau}-\hat{y}_{\tau}|}{|y_{\tau}|}
      ```
  
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: MAPE.
      """
      _metric_protections(y, y_hat, weights)
  
      delta_y = np.abs(y - y_hat)
      scale = np.abs(y)
      mape = _divide_no_nan(delta_y, scale)
      mape = np.average(mape, weights=weights, axis=axis)
  
      return mape
  
  
  def smape(
      y: np.ndarray,
      y_hat: np.ndarray,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Symmetric Mean Absolute Percentage Error
  
      Calculates Symmetric Mean Absolute Percentage Error between
      `y` and `y_hat`. SMAPE measures the relative prediction
      accuracy of a forecasting method by calculating the relative deviation
      of the prediction and the observed value scaled by the sum of the
      absolute values for the prediction and observed value at a
      given time, then averages these devations over the length
      of the series. This allows the SMAPE to have bounds between
      0% and 200% which is desirable compared to normal MAPE that
      may be undetermined when the target is zero.
  
      ```math
      \mathrm{sMAPE}_{2}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \frac{|y_{\tau}-\hat{y}_{\tau}|}{|y_{\tau}|+|\hat{y}_{\tau}|}
      ```
  
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: SMAPE.
  
      References:
          - [Makridakis S., "Accuracy measures: theoretical and practical concerns".](https://www.sciencedirect.com/science/article/pii/0169207093900793)
      """
      _metric_protections(y, y_hat, weights)
  
      delta_y = np.abs(y - y_hat)
      scale = np.abs(y) + np.abs(y_hat)
      smape = _divide_no_nan(delta_y, scale)
      smape = 2 * np.average(smape, weights=weights, axis=axis)
  
      if np.isscalar(smape):
          assert smape <= 2, "SMAPE should be lower than 200"
      else:
          assert all(smape <= 2), "SMAPE should be lower than 200"
  
      return smape
  
  
  def mase(
      y: np.ndarray,
      y_hat: np.ndarray,
      y_train: np.ndarray,
      seasonality: int,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Mean Absolute Scaled Error
      Calculates the Mean Absolute Scaled Error between
      `y` and `y_hat`. MASE measures the relative prediction
      accuracy of a forecasting method by comparinng the mean absolute errors
      of the prediction and the observed value against the mean
      absolute errors of the seasonal naive model.
      The MASE partially composed the Overall Weighted Average (OWA),
      used in the M4 Competition.
  
      ```math
      \mathrm{MASE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}, \mathbf{\hat{y}}^{season}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \frac{|y_{\tau}-\hat{y}_{\tau}|}{\mathrm{MAE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{season}_{\tau})}
      ```
  
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          y_insample (np.ndarray): Actual insample Seasonal Naive predictions.
          seasonality (int): Main frequency of the time series; Hourly 24,  Daily 7, Weekly 52, Monthly 12, Quarterly 4, Yearly 1.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: MASE.
  
      References:
          - [Rob J. Hyndman, & Koehler, A. B. "Another look at measures of forecast accuracy".](https://www.sciencedirect.com/science/article/pii/S0169207006000239)
          - [Spyros Makridakis, Evangelos Spiliotis, Vassilios Assimakopoulos, "The M4 Competition: 100,000 time series and 61 forecasting methods".](https://www.sciencedirect.com/science/article/pii/S0169207019301128)
      """
      delta_y = np.abs(y - y_hat)
      delta_y = np.average(delta_y, weights=weights, axis=axis)
  
      scale = np.abs(y_train[:-seasonality] - y_train[seasonality:])
      scale = np.average(scale, axis=axis)
  
      mase = delta_y / scale
  
      return mase
  
  
  def rmae(
      y: np.ndarray,
      y_hat1: np.ndarray,
      y_hat2: np.ndarray,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""RMAE
  
      Calculates Relative Mean Absolute Error (RMAE) between
      two sets of forecasts (from two different forecasting methods).
      A number smaller than one implies that the forecast in the
      numerator is better than the forecast in the denominator.
  
      ```math
      \mathrm{rMAE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}_{\tau}, \mathbf{\hat{y}}^{base}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \frac{|y_{\tau}-\hat{y}_{\tau}|}{\mathrm{MAE}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{base}_{\tau})}
      ```
  
      Args:
          y (np.ndarray): observed values.
          y_hat1 (np.ndarray): Predicted values of first model.
          y_hat2 (np.ndarray): Predicted values of baseline model.
          weights (np.ndarray, optional): Weights for weighted average. Defaults to None.
          axis (Optional[int], optional): Axis or axes along which to average a. Defaults to None.
          The default, axis=None, will average over all of the elements of
          the input array.
  
      Returns:
          float: RMAE.
  
      References:
          - [Rob J. Hyndman, & Koehler, A. B. "Another look at measures of forecast accuracy".](https://www.sciencedirect.com/science/article/pii/S0169207006000239)
      """
      numerator = mae(y=y, y_hat=y_hat1, weights=weights, axis=axis)
      denominator = mae(y=y, y_hat=y_hat2, weights=weights, axis=axis)
      rmae = numerator / denominator
  
      return rmae
  
  
  def quantile_loss(
      y: np.ndarray,
      y_hat: np.ndarray,
      q: float = 0.5,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Quantile Loss
  
      Computes the quantile loss between `y` and `y_hat`.
      QL measures the deviation of a quantile forecast.
      By weighting the absolute deviation in a non symmetric way, the
      loss pays more attention to under or over estimation.
      A common value for q is 0.5 for the deviation from the median (Pinball loss).
  
      ```math
      \mathrm{QL}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{(q)}_{\tau}) = \frac{1}{H} \sum^{t+H}_{\tau=t+1} \Big( (1-q)\,( \hat{y}^{(q)}_{\tau} - y_{\tau} )_{+} + q\,( y_{\tau} - \hat{y}^{(q)}_{\tau} )_{+} \Big)
      ```
  
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          q (float, optional): The slope of the quantile loss, in the context of quantile regression, the q determines the conditional quantile level. Defaults to 0.5.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: Quantile loss.
  
      References:
          - [Roger Koenker and Gilbert Bassett, Jr., "Regression Quantiles".](https://www.jstor.org/stable/1913643)
      """
      _metric_protections(y, y_hat, weights)
  
      delta_y = y - y_hat
      loss = np.maximum(q * delta_y, (q - 1) * delta_y)
  
      if weights is not None:
          quantile_loss = np.average(
              loss[~np.isnan(loss)], weights=weights[~np.isnan(loss)], axis=axis
          )
      else:
          quantile_loss = np.nanmean(loss, axis=axis)
  
      return quantile_loss
  
  
  def mqloss(
      y: np.ndarray,
      y_hat: np.ndarray,
      quantiles: np.ndarray,
      weights: Optional[np.ndarray] = None,
      axis: Optional[int] = None,
  ) -> Union[float, np.ndarray]:
      r"""Multi-Quantile loss
  
      Calculates the Multi-Quantile loss (MQL) between `y` and `y_hat`.
      MQL calculates the average multi-quantile Loss for
      a given set of quantiles, based on the absolute
      difference between predicted quantiles and observed values.
  
      ```math
      \mathrm{MQL}(\mathbf{y}_{\tau},[\mathbf{\hat{y}}^{(q_{1})}_{\tau}, ... ,\hat{y}^{(q_{n})}_{\tau}]) = \frac{1}{n} \sum_{q_{i}} \mathrm{QL}(\mathbf{y}_{\tau}, \mathbf{\hat{y}}^{(q_{i})}_{\tau})
      ```
  
  
      The limit behavior of MQL allows to measure the accuracy
      of a full predictive distribution $\mathbf{\hat{F}}_{\tau}$ with
      the continuous ranked probability score (CRPS). This can be achieved
      through a numerical integration technique, that discretizes the quantiles
      and treats the CRPS integral with a left Riemann approximation, averaging over
      uniformly distanced quantiles.
  
      ```math
      \mathrm{CRPS}(y_{\tau}, \mathbf{\hat{F}}_{\tau}) = \int^{1}_{0} \mathrm{QL}(y_{\tau}, \hat{y}^{(q)}_{\tau}) dq
      ```
  
  
      Args:
          y (np.ndarray): Actual values.
          y_hat (np.ndarray): Predicted values.
          quantiles (np.ndarray): Quantiles to estimate from the distribution of y.
          mask (np.ndarray, optional): Specifies date stamps per serie to consider in loss. Defaults to None.
  
      Returns:
          float: MQLoss.
  
      References:
          - [Roger Koenker and Gilbert Bassett, Jr., "Regression Quantiles".](https://www.jstor.org/stable/1913643)
      [James E. Matheson and Robert L. Winkler, "Scoring Rules for Continuous Probability Distributions".](https://www.jstor.org/stable/2629907)
      """
      if weights is None:
          weights = np.ones(y.shape)
  
      _metric_protections(y, y_hat, weights)
      n_q = len(quantiles)
  
      y_rep = np.expand_dims(y, axis=-1)
      error = y_hat - y_rep
      sq = np.maximum(-error, np.zeros_like(error))
      s1_q = np.maximum(error, np.zeros_like(error))
      mqloss = quantiles * sq + (1 - quantiles) * s1_q
  
      # Match y/weights dimensions and compute weighted average
      weights = np.repeat(np.expand_dims(weights, axis=-1), repeats=n_q, axis=-1)
      mqloss = np.average(mqloss, weights=weights, axis=axis)
  
      return mqloss
  