fedbiomed.common.metrics

@staticmethod
def get_all_metrics() -> List[str]:
    return [metric.name for metric in MetricTypes]

@staticmethod
def get_metric_type_by_name(metric_name: str):
    for metric in MetricTypes:
        if metric.name == metric_name:
            return metric

def metric_category(self) -> _MetricCategory:
    return self._metric_category

@staticmethod
def accuracy(y_true: Union[np.ndarray, list],
             y_pred: Union[np.ndarray, list],
             **kwargs: dict) -> float:
    """ Evaluate the accuracy score

    Source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html

    Args:
        y_true: True values
        y_pred: Predicted values
        **kwargs: Extra arguments from [`sklearn.metrics.accuracy_score`][sklearn.metrics.accuracy_score]

    Returns:
        Accuracy score

    Raises:
        FedbiomedMetricError: raised if above sklearn method raises
    """

    try:
        y_true, y_pred, _, _ = Metrics._configure_multiclass_parameters(y_true, y_pred, kwargs, 'ACCURACY')
        return metrics.accuracy_score(y_true, y_pred, **kwargs)
    except Exception as e:
        msg = ErrorNumbers.FB611.value + " Exception raised from SKLEARN metrics: " + str(e)
        raise FedbiomedMetricError(msg)

def evaluate(self,
             y_true: Union[np.ndarray, list],
             y_pred: Union[np.ndarray, list],
             metric: MetricTypes,
             **kwargs: dict) -> Union[int, float]:
    """Perform evaluation based on given metric.

    This method configures given y_pred and y_true to make them compatible with default evaluation methods.

    Args:
        y_true: True values
        y_pred: Predicted values
        metric: An instance of MetricTypes to chose metric that will be used for evaluation
        **kwargs: The arguments specifics to each type of metrics.

    Returns:
        Result of the evaluation function

    Raises:
        FedbiomedMetricError: in case of invalid metric, y_true and y_pred types
    """
    if not isinstance(metric, MetricTypes):
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: Metric should instance of `MetricTypes`")

    if y_true is not None and not isinstance(y_true, (np.ndarray, list)):
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: The argument `y_true` should an instance "
                                   f"of `np.ndarray`, but got {type(y_true)} ")

    if y_pred is not None and not isinstance(y_pred, (np.ndarray, list)):
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: The argument `y_pred` should an instance "
                                   f"of `np.ndarray`, but got {type(y_true)} ")

    y_true, y_pred = self._configure_y_true_pred_(y_true=y_true, y_pred=y_pred, metric=metric)
    result = self.metrics[metric.name](y_true, y_pred, **kwargs)

    return result

@staticmethod
def explained_variance(y_true: Union[np.ndarray, list],
                       y_pred: Union[np.ndarray, list],
                       **kwargs: dict) -> float:
    """Evaluate the Explained variance regression score.

    Source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.explained_variance_score.html]

    Args:
        y_true: True values
        y_pred: Predicted values
        **kwargs: Extra arguments from [`sklearn.metrics.explained_variance_score`]
            [sklearn.metrics.explained_variance_score]

    Returns:
        EV score (float or ndarray of floats)

    Raises:
        FedbiomedMetricError: raised if above sklearn method for computing precision raises
    """

    # Set multiouput as raw_values is it is not defined by researcher
    if len(y_true.shape) > 1:
        multi_output = kwargs.get('multioutput', 'raw_values')
    else:
        multi_output = None

    kwargs.pop('multioutput', None)

    try:
        return metrics.explained_variance_score(y_true, y_pred, multioutput=multi_output, **kwargs)
    except Exception as e:
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: Error during calculation of `EXPLAINED_VARIANCE`"
                                   f" {str(e)}")

@staticmethod
def f1_score(y_true: Union[np.ndarray, list],
             y_pred: Union[np.ndarray, list],
             **kwargs: dict) -> float:
    """Evaluate the F1 score.

    Source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html

    Args:
        y_true: True values
        y_pred: Predicted values
        **kwargs: Extra arguments from [`sklearn.metrics.f1_score`][sklearn.metrics.f1_score]

    Returns:
        f1_score (float or array of float, shape = [n_unique_labels])

    Raises:
        FedbiomedMetricError: raised if above sklearn method for computing precision raises
    """

    # Get average and pob_label argument based on multiclass status
    y_true, y_pred, average, pos_label = Metrics._configure_multiclass_parameters(y_true,
                                                                                  y_pred,
                                                                                  kwargs,
                                                                                  'F1_SCORE')

    kwargs.pop("average", None)
    kwargs.pop("pos_label", None)

    try:
        return metrics.f1_score(y_true, y_pred, average=average, pos_label=pos_label, **kwargs)
    except Exception as e:
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: Error during calculation of `F1_SCORE` {str(e)}")

@staticmethod
def mae(y_true: Union[np.ndarray, list],
        y_pred: Union[np.ndarray, list],
        **kwargs: dict) -> float:
    """Evaluate the mean absolute error.

    Source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html

    Args:
        y_true: True values
        y_pred: Predicted values
        **kwargs: Extra arguments from [`sklearn.metrics.mean_absolute_error`][sklearn.metrics.mean_absolute_error]

    Returns:
        MAE score (float or ndarray of floats)

    Raises:
        FedbiomedMetricError: raised if above sklearn method for computing precision raises
    """
    # Set multiouput as raw_values is it is not defined by researcher
    if len(y_true.shape) > 1:
        multi_output = kwargs.get('multioutput', 'raw_values')
    else:
        multi_output = None

    kwargs.pop('multioutput', None)

    try:
        return metrics.mean_absolute_error(y_true, y_pred, multioutput=multi_output, **kwargs)
    except Exception as e:
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: Error during calculation of `MEAN_ABSOLUTE_ERROR`"
                                   f" {str(e)}")

@staticmethod
def mse(y_true: Union[np.ndarray, list],
        y_pred: Union[np.ndarray, list],
        **kwargs: dict) -> float:
    """Evaluate the mean squared error.

    Source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html

    Args:
        y_true: True values
        y_pred: Predicted values
        **kwargs: Extra arguments from [`sklearn.metrics.mean_squared_error`][sklearn.metrics.mean_squared_error]

    Returns:
        MSE score (float or ndarray of floats)

    Raises:
        FedbiomedMetricError: raised if above sklearn method for computing precision raises
    """

    # Set multiouput as raw_values is it is not defined by researcher
    if len(y_true.shape) > 1:
        multi_output = kwargs.get('multioutput', 'raw_values')
    else:
        multi_output = None

    kwargs.pop('multioutput', None)

    try:
        return metrics.mean_squared_error(y_true, y_pred, multioutput=multi_output, **kwargs)
    except Exception as e:
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: Error during calculation of `MEAN_SQUARED_ERROR`"
                                   f" {str(e)}")

@staticmethod
def precision(y_true: Union[np.ndarray, list],
              y_pred: Union[np.ndarray, list],
              **kwargs: dict) -> float:
    """Evaluate the precision score
    [source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html]

    Args:
        y_true: True values
        y_pred: Predicted values
        **kwargs: Extra arguments from [`sklearn.metrics.precision_score`][sklearn.metrics.precision_score]

    Returns:
        precision (float, or array of float of shape (n_unique_labels,))

    Raises:
        FedbiomedMetricError: raised if above sklearn method for computing precision raises
    """
    # Get average and pob_label argument based on multiclass status
    y_true, y_pred, average, pos_label = Metrics._configure_multiclass_parameters(y_true,
                                                                                  y_pred,
                                                                                  kwargs,
                                                                                  'PRECISION')

    kwargs.pop("average", None)
    kwargs.pop("pos_label", None)

    try:
        return metrics.precision_score(y_true, y_pred, average=average, pos_label=pos_label, **kwargs)
    except Exception as e:
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: Error during calculation of `PRECISION` "
                                   f"calculation: {str(e)}")

@staticmethod
def recall(y_true: Union[np.ndarray, list],
           y_pred: Union[np.ndarray, list],
           **kwargs: dict) -> float:
    """Evaluate the recall.
    [source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html]

    Args:
        y_true: True values
        y_pred: Predicted values
        **kwargs: Extra arguments from [`sklearn.metrics.recall_score`][sklearn.metrics.recall_score]

    Returns:
        recall (float (if average is not None) or array of float of shape (n_unique_labels,))

    Raises:
        FedbiomedMetricError: raised if above sklearn method for computing precision raises
    """

    # Get average and pob_label argument based on multiclass status
    y_true, y_pred, average, pos_label = Metrics._configure_multiclass_parameters(y_true, y_pred, kwargs, 'RECALL')

    kwargs.pop("average", None)
    kwargs.pop("pos_label", None)

    try:
        return metrics.recall_score(y_true, y_pred, average=average, pos_label=pos_label, **kwargs)
    except Exception as e:
        raise FedbiomedMetricError(f"{ErrorNumbers.FB611.value}: Error during calculation of `RECALL` "
                                   f"calculation: {str(e)}")