code: def median_relative_absolute_error(
      y_true,
      y_pred,
      horizon_weight=None,
      multioutput="uniform_average",
      **kwargs,
  ):
      """Median relative absolute error (MdRAE).
  
      In relative error metrics, relative errors are first calculated by
      scaling (dividing) the individual forecast errors by the error calculated
      using a benchmark method at the same index position. If the error of the
      benchmark method is zero then a large value is returned.
  
      MdRAE applies medan absolute error (MdAE) to the resulting relative errors.
  
      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.
  
      y_pred_benchmark : pd.Series, pd.DataFrame or np.array of shape (fh,) or \
               (fh, n_outputs) where fh is the forecasting horizon, default=None
          Forecasted values from benchmark method.
  
      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
      -------
      loss : float
          MdRAE loss.
          If multioutput is 'raw_values', then MdRAE is returned for each
          output separately.
          If multioutput is 'uniform_average' or an ndarray of weights, then the
          weighted average MdRAE of all output errors is returned.
  
      See Also
      --------
      mean_relative_absolute_error
      geometric_mean_relative_absolute_error
      geometric_mean_relative_squared_error
  
      References
      ----------
      Hyndman, R. J and Koehler, A. B. (2006). "Another look at measures of
      forecast accuracy", International Journal of Forecasting, Volume 22, Issue 4.
  
      Examples
      --------
      >>> from sktime.performance_metrics.forecasting import \
          median_relative_absolute_error
      >>> y_true = np.array([3, -0.5, 2, 7, 2])
      >>> y_pred = np.array([2.5, 0.0, 2, 8, 1.25])
      >>> y_pred_benchmark = y_pred*1.1
      >>> median_relative_absolute_error(y_true, y_pred, \
      y_pred_benchmark=y_pred_benchmark)
      1.0
      >>> y_true = np.array([[0.5, 1], [-1, 1], [7, -6]])
      >>> y_pred = np.array([[0, 2], [-1, 2], [8, -5]])
      >>> y_pred_benchmark = y_pred*1.1
      >>> median_relative_absolute_error(y_true, y_pred, \
      y_pred_benchmark=y_pred_benchmark)
      0.6944444444444443
      >>> median_relative_absolute_error(y_true, y_pred, \
      y_pred_benchmark=y_pred_benchmark, multioutput='raw_values')
      array([0.55555556, 0.83333333])
      >>> median_relative_absolute_error(y_true, y_pred, \
      y_pred_benchmark=y_pred_benchmark, multioutput=[0.3, 0.7])
      0.7499999999999999
      """
      y_pred_benchmark = _get_kwarg(
          "y_pred_benchmark",
          metric_name="median_relative_absolute_error",
          **kwargs,
      )
      _, y_true, y_pred, multioutput = _check_reg_targets(
          y_true, y_pred, multioutput
      )
      _, y_true, y_pred_benchmark, multioutput = _check_reg_targets(
          y_true, y_pred_benchmark, multioutput
      )
  
      if horizon_weight is None:
          output_errors = np.median(
              np.abs(_relative_error(y_true, y_pred, y_pred_benchmark)),
              axis=0,
          )
      else:
          check_consistent_length(y_true, horizon_weight)
          output_errors = _weighted_percentile(
              np.abs(_relative_error(y_true, y_pred, y_pred_benchmark)),
              sample_weight=horizon_weight,
          )
  
      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 19 for calling a global function with example usage: median_relative_absolute_error(y_true, y_pred, horizon_weight, multioutput) and returns: np, output_errors