code: def mean_absolute_percentage_error(
      y_true: ArrayLike,
      y_pred: ArrayLike,
      sample_weight: Optional[ArrayLike] = None,
      multioutput: Optional[str] = "uniform_average",
      compute: bool = True,
  ) -> ArrayLike:
      """Mean absolute percentage error regression loss.
  
      Note here that we do not represent the output as a percentage in range
      [0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in
      https://scikit-learn.org/stable/modules/model_evaluation.html#mean-absolute-percentage-error
  
      Parameters
      ----------
      y_true : array-like of shape (n_samples,) or (n_samples, n_outputs)
          Ground truth (correct) target values.
      y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs)
          Estimated target values.
      sample_weight : array-like of shape (n_samples,), default=None
          Sample weights.
      multioutput : {'raw_values', 'uniform_average'} or array-like
          Defines aggregating of multiple output values.
          Array-like value defines weights used to average errors.
          If input is list then the shape must be (n_outputs,).
          'raw_values' :
              Returns a full set of errors in case of multioutput input.
          'uniform_average' :
              Errors of all outputs are averaged with uniform weight.
      compute : bool
          Whether to compute this result (default ``True``)
  
      Returns
      -------
      loss : float or array-like of floats in the range [0, 1/eps]
          If multioutput is 'raw_values', then mean absolute percentage error
          is returned for each output separately.
          If multioutput is 'uniform_average' or ``None``, then the
          equally-weighted average of all output errors is returned.
          MAPE output is non-negative floating point. The best value is 0.0.
          But note the fact that bad predictions can lead to arbitarily large
          MAPE values, especially if some y_true values are very close to zero.
          Note that we return a large value instead of `inf` when y_true is zero.
      """
      _check_sample_weight(sample_weight)
      epsilon = np.finfo(np.float64).eps
      mape = abs(y_pred - y_true) / da.maximum(y_true, epsilon)
      output_errors = mape.mean(axis=0)
  
      if isinstance(multioutput, str) or multioutput is None:
          if multioutput == "raw_values":
              if compute:
                  return output_errors.compute()
              else:
                  return output_errors
      else:
          raise ValueError("Weighted 'multioutput' not supported.")
      result = output_errors.mean()
      if compute:
          result = result.compute()
      return result
  
file_path: dask-ml/dask_ml/metrics/regression.py
imports: from typing import Optional
  import dask.array
  import numpy
  import sklearn.metrics
  from dask import is_dask_collection
  from dask.utils import derived_from
  from .._typing import ArrayLike
label_desc: Use image node_id 5 for calling a global function with example usage: mean_absolute_percentage_error(y_true, y_pred, sample_weight, multioutput, compute) and returns: result, output_errors, output_errors