Metrics Reference¶

@classmethod
def populate_object_with_metrics(cls, actual: pd.Series, predicted: pd.Series) -> "AccuracyMetricResults":
    """Populate the object with the calculated metrics.

    Args:
        actual: The actual values
        predicted: The predicted values

    Returns:
        AccuracyMetricResults object with the metrics

    """
    return cls(
        mape=mean_absolute_percentage_error(actual, predicted) * 100,
        smape=calculate_smape(actual, predicted),
        r_squared=r2_score(actual, predicted),
    )

def to_df(self) -> pd.DataFrame:
    """Convert the accuracy metric results to a long DataFrame format."""
    df = pd.DataFrame(
        [
            self._create_single_metric_dataframe_row(
                general_metric_name=AccuracyMetricNames.MAPE.value,
                specific_metric_name=AccuracyMetricNames.MAPE.value,
                metric_value=self.mape,
            ),
            self._create_single_metric_dataframe_row(
                general_metric_name=AccuracyMetricNames.SMAPE.value,
                specific_metric_name=AccuracyMetricNames.SMAPE.value,
                metric_value=self.smape,
            ),
            self._create_single_metric_dataframe_row(
                general_metric_name=AccuracyMetricNames.R_SQUARED.value,
                specific_metric_name=AccuracyMetricNames.R_SQUARED.value,
                metric_value=self.r_squared,
            ),
        ]
    )
    return self.add_pass_fail_column(df)

def to_df(self) -> pd.DataFrame:
    """Convert the cross-validation metric results to a long DataFrame format."""
    df = pd.DataFrame(
        [
            self._create_single_metric_dataframe_row(
                general_metric_name=CrossValidationMetricNames.MEAN_MAPE.value,
                specific_metric_name=CrossValidationMetricNames.MEAN_MAPE.value,
                metric_value=self.mean_mape,
            ),
            self._create_single_metric_dataframe_row(
                general_metric_name=CrossValidationMetricNames.STD_MAPE.value,
                specific_metric_name=CrossValidationMetricNames.STD_MAPE.value,
                metric_value=self.std_mape,
            ),
            self._create_single_metric_dataframe_row(
                general_metric_name=CrossValidationMetricNames.MEAN_SMAPE.value,
                specific_metric_name=CrossValidationMetricNames.MEAN_SMAPE.value,
                metric_value=self.mean_smape,
            ),
            self._create_single_metric_dataframe_row(
                general_metric_name=CrossValidationMetricNames.STD_SMAPE.value,
                specific_metric_name=CrossValidationMetricNames.STD_SMAPE.value,
                metric_value=self.std_smape,
            ),
            self._create_single_metric_dataframe_row(
                general_metric_name=CrossValidationMetricNames.MEAN_R_SQUARED.value,
                specific_metric_name=CrossValidationMetricNames.MEAN_R_SQUARED.value,
                metric_value=self.mean_r_squared,
            ),
        ]
    )
    return self.add_pass_fail_column(df)

@classmethod
def to_list(cls) -> list[str]:
    """Convert the enum to a list of strings."""
    return [member.value for member in cls]

def add_pass_fail_column(self, df: pd.DataFrame) -> pd.DataFrame:
    """Add a pass/fail column to the DataFrame based on metric thresholds.

    Args:
        df: DataFrame with general_metric_name and metric_value columns

    Returns:
        DataFrame with additional metric_pass column

    """
    df_copy = df.copy()
    df_copy[TestResultDFAttributes.METRIC_PASS.value] = df_copy.apply(
        lambda row: self._check_metric_threshold(
            row[TestResultDFAttributes.GENERAL_METRIC_NAME.value], row[TestResultDFAttributes.METRIC_VALUE.value]
        ),
        axis=1,
    )
    return df_copy

def to_df(self) -> pd.DataFrame:
    """Convert the class of test results to a flat DataFrame format."""
    raise NotImplementedError("This method should be implemented by the subclass.")

def to_dict(self) -> dict[str, Any]:
    """Convert the class of test results to dictionary format."""
    return self.model_dump()

def to_df(self) -> pd.DataFrame:
    """Convert the perturbation metric results to a long DataFrame format."""
    df = pd.DataFrame(
        self._create_channel_based_metric_dataframe_rows(
            channel_series=self.percentage_change_for_each_channel,
            metric_name=PerturbationMetricNames.PERCENTAGE_CHANGE,
        )
    )
    return self.add_pass_fail_column(df)

def to_df(self) -> pd.DataFrame:
    """Convert the placebo test metric results to a long DataFrame format."""
    df = pd.DataFrame(
        [
            self._create_single_metric_dataframe_row(
                general_metric_name=PlaceboMetricNames.SHUFFLED_CHANNEL_ROI.value,
                specific_metric_name=f"{PlaceboMetricNames.SHUFFLED_CHANNEL_ROI.value}_{self.shuffled_channel_name}",
                metric_value=self.shuffled_channel_roi,
            ),
        ]
    )
    return self.add_pass_fail_column(df)

def to_df(self) -> pd.DataFrame:
    """Convert the refresh stability metric results to a long DataFrame format."""
    rows = []

    # Add mean and std percentage change for each channel
    rows.extend(
        self._create_channel_based_metric_dataframe_rows(
            channel_series=self.mean_percentage_change_for_each_channel,
            metric_name=RefreshStabilityMetricNames.MEAN_PERCENTAGE_CHANGE,
        )
    )
    rows.extend(
        self._create_channel_based_metric_dataframe_rows(
            channel_series=self.std_percentage_change_for_each_channel,
            metric_name=RefreshStabilityMetricNames.STD_PERCENTAGE_CHANGE,
        )
    )

    df = pd.DataFrame(rows)
    return self.add_pass_fail_column(df)