code: def mean_linex_error(
      y_true,
      y_pred,
      a=1.0,
      b=1.0,
      horizon_weight=None,
      multioutput="uniform_average",
      **kwargs,
  ):
      """Calculate mean linex error.
  
      Output is non-negative floating point. The best value is 0.0.
  
      Many forecasting loss functions (like those discussed in [1]_) assume that
      over- and under- predictions should receive an equal penalty. However, this
      may not align with the actual cost faced by users' of the forecasts.
      Asymmetric loss functions are useful when the cost of under- and over-
      prediction are not the same.
  
      The linex error function accounts for this by penalizing errors on one side
      of a threshold approximately linearly, while penalizing errors on the other
      side approximately exponentially.
  
      Parameters
      ----------
      y_true : pd.Series, pd.DataFrame or np.array of shape (fh,) or (fh, n_outputs) \
               where fh is the forecasting horizon
          Ground truth (correct) target values.
      y_pred : pd.Series, pd.DataFrame or np.array of shape (fh,) or (fh, n_outputs) \
               where fh is the forecasting horizon
          Forecasted values.
      a : int or float
          Controls whether over- or under- predictions receive an approximately
          linear or exponential penalty. If `a` > 0 then negative errors
          (over-predictions) are penalized approximately linearly and positive errors
          (under-predictions) are penalized approximately exponentially. If `a` < 0
          the reverse is true.
      b : int or float
          Multiplicative penalty to apply to calculated errors.
      horizon_weight : array-like of shape (fh,), default=None
          Forecast horizon weights.
      multioutput : {'raw_values', 'uniform_average'}  or array-like of shape \
              (n_outputs,), default='uniform_average'
          Defines how to aggregate metric for multivariate (multioutput) data.
          If array-like, values used as weights to average the errors.
          If 'raw_values', returns a full set of errors in case of multioutput input.
          If 'uniform_average', errors of all outputs are averaged with uniform weight.
  
      Returns
      -------
      asymmetric_loss : float
          Loss using asymmetric penalty of on errors.
          If multioutput is 'raw_values', then asymmetric loss is returned for
          each output separately.
          If multioutput is 'uniform_average' or an ndarray of weights, then the
          weighted average asymmetric loss of all output errors is returned.
  
      See Also
      --------
      mean_asymmetric_error
  
      Notes
      -----
      Calculated as b * (np.exp(a * error) - a * error - 1), where a != 0 and b > 0
      according to formula in [2]_.
  
      References
      ----------
      .. [1] Hyndman, R. J and Koehler, A. B. (2006). "Another look at measures of
         forecast accuracy", International Journal of Forecasting, Volume 22, Issue 4.
  
      .. [1] Diebold, Francis X. (2007). "Elements of Forecasting (4th ed.)",
         Thomson, South-Western: Ohio, US.
  
      Examples
      --------
      >>> import numpy as np
      >>> from sktime.performance_metrics.forecasting import mean_linex_error
      >>> y_true = np.array([3, -0.5, 2, 7, 2])
      >>> y_pred = np.array([2.5, 0.0, 2, 8, 1.25])
      >>> mean_linex_error(y_true, y_pred)  # doctest: +SKIP
      0.19802627763937575
      >>> mean_linex_error(y_true, y_pred, b=2)  # doctest: +SKIP
      0.3960525552787515
      >>> mean_linex_error(y_true, y_pred, a=-1)  # doctest: +SKIP
      0.2391800623225643
      >>> y_true = np.array([[0.5, 1], [-1, 1], [7, -6]])
      >>> y_pred = np.array([[0, 2], [-1, 2], [8, -5]])
      >>> mean_linex_error(y_true, y_pred)  # doctest: +SKIP
      0.2700398392309829
      >>> mean_linex_error(y_true, y_pred, a=-1)  # doctest: +SKIP
      0.49660966225813563
      >>> mean_linex_error(y_true, y_pred, multioutput='raw_values')  # doctest: +SKIP
      array([0.17220024, 0.36787944])
      >>> mean_linex_error(y_true, y_pred, multioutput=[0.3, 0.7])  # doctest: +SKIP
      0.30917568000716666
      """
      _, y_true, y_pred, multioutput = _check_reg_targets(
          y_true, y_pred, multioutput
      )
      if horizon_weight is not None:
          check_consistent_length(y_true, horizon_weight)
  
      linex_error = _linex_error(y_true, y_pred, a=a, b=b)
      output_errors = np.average(
          linex_error, weights=horizon_weight, axis=0
      )
  
      if isinstance(multioutput, str):
          if multioutput == "raw_values":
              return output_errors
          elif multioutput == "uniform_average":
              # pass None as weights to np.average: uniform mean
              multioutput = None
  
      return np.average(output_errors, weights=multioutput)
  
imports: import numpy
  from scipy.stats import gmean
  from sklearn.metrics import mean_absolute_error
  from sklearn.metrics import mean_squared_error
  from sklearn.metrics import median_absolute_error
  from sklearn.metrics._regression import _check_reg_targets
  from sklearn.utils.stats import _weighted_percentile
  from sklearn.utils.validation import check_consistent_length
  from sktime.utils.stats import _weighted_geometric_mean
label_desc: Use image node_id 2 for calling a global function with example usage: mean_linex_error(y_true, y_pred, a, b, horizon_weight, multioutput) and returns: np, output_errors