utilsds-models 0.0.1__py3-none-any.whl

utilsds-models/data_processing.py

@@ -0,0 +1,396 @@
+"""Data processing classes compatible with scikit-learn pipelines"""
+
+from collections import Counter
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.preprocessing import LabelEncoder
+
+
+class ColumnCopyImputer(BaseEstimator, TransformerMixin):  # type: ignore[misc]
+    """
+    Imputes values by copying from other columns.
+
+    Parameters
+    ----------
+    copy_mapping : dict
+        Mapping: {'target_column': 'source_column'}
+    """
+
+    def __init__(self, copy_mapping: Dict[str, str]):
+        self.copy_mapping = copy_mapping
+
+    def fit(self, X: pd.DataFrame, y: Optional[Any] = None) -> "ColumnCopyImputer":
+        self.is_fitted_ = True
+        return self
+
+    def transform(self, X: pd.DataFrame, y: Optional[Any] = None) -> pd.DataFrame:
+        X_transformed = X.copy()
+
+        for target_col, source_col in self.copy_mapping.items():
+            if target_col in X_transformed.columns and source_col in X_transformed.columns:
+                null_mask = X_transformed[target_col].isnull()
+                values_to_copy = X_transformed.loc[null_mask, source_col]
+
+                if pd.api.types.is_integer_dtype(values_to_copy.dtype):
+                    # Jeśli źródło to Int64, konwertuj na float
+                    values_to_copy = values_to_copy.astype("float32")
+
+                X_transformed.loc[null_mask, target_col] = values_to_copy
+
+        return X_transformed
+
+
+class NullImputerWithFlags(BaseEstimator, TransformerMixin):  # type: ignore[misc]
+    """
+    Imputes null values and creates flag columns for selected columns.
+
+    Parameters
+    ----------
+    columns : list
+        List of columns to impute
+    values : dict or any
+        Values for imputation. If dict, maps columns to values.
+        If single value, uses it for all columns.
+    flag_columns : list, optional
+        List of columns for which to create flags (whether value existed before imputation)
+    flag_suffix : str, default='_isnull_flag'
+        Suffix for flag column names
+    strategy : str, optional
+        Imputation strategy: 'mean', 'median', 'mode' (overrides values)
+    """
+
+    def __init__(
+        self,
+        columns: List[str],
+        values: Union[Dict[str, Any], Any] = None,
+        flag_columns: Optional[List[str]] = None,
+        flag_suffix: str = "_isnull_flag",
+        strategy: Optional[str] = None,
+    ):
+
+        self.columns = columns
+        self.values = values
+        self.flag_columns = flag_columns or []
+        self.flag_suffix = flag_suffix
+        self.strategy = strategy
+        self._fitted_values: Dict[str, Any] = {}
+
+        # Walidacja
+        if self.values is None and self.strategy is None:
+            raise ValueError("Either 'values' or 'strategy' must be provided")
+
+        if self.strategy and self.strategy not in ["mean", "median", "mode"]:
+            raise ValueError("strategy must be one of: 'mean', 'median', 'mode'")
+
+    def fit(self, X: pd.DataFrame, y: Optional[Any] = None) -> "NullImputerWithFlags":
+        """
+        Learn values for imputation (if using strategy).
+        """
+        if self.strategy is not None:
+            for column in self.columns:
+                if column in X.columns:
+                    if self.strategy == "mean":
+                        self._fitted_values[column] = X[column].mean()
+                    elif self.strategy == "median":
+                        self._fitted_values[column] = X[column].median()
+                    elif self.strategy == "mode":
+                        mode_result = X[column].mode()
+                        self._fitted_values[column] = mode_result[0] if len(mode_result) > 0 else 0
+
+        return self
+
+    def transform(self, X: pd.DataFrame, y: Optional[Any] = None) -> pd.DataFrame:
+        """
+        Impute values and create flags.
+        """
+        X_transformed = X.copy()
+
+        # 1. NAJPIERW STWÓRZ FLAGI (przed imputacją!)
+        for column in self.flag_columns:
+            if column in X_transformed.columns:
+                flag_name = f"{column}{self.flag_suffix}"
+                X_transformed[flag_name] = X_transformed[column].isnull().astype(int)
+
+        # 2. POTEM IMPUTUJ WARTOŚCI
+        for column in self.columns:
+            if column in X_transformed.columns:
+
+                # Określ wartość do imputacji
+                if self.strategy is not None and column in self._fitted_values:
+                    fill_value = self._fitted_values[column]
+                elif isinstance(self.values, dict) and column in self.values:
+                    fill_value = self.values[column]
+                elif not isinstance(self.values, dict):
+                    fill_value = self.values
+                else:
+                    continue  # Pomiń jeśli nie ma wartości dla tej kolumny
+
+                # Imputuj
+                X_transformed[column] = X_transformed[column].fillna(fill_value)
+
+        return X_transformed
+
+
+class MaxMultiplierImputer(BaseEstimator, TransformerMixin):  # type: ignore[misc]
+    """
+    Imputes values based on maximum * multiplier from training data.
+    Optionally creates flags for columns that had values before imputation.
+
+    Parameters
+    ----------
+    columns : list
+        List of columns to impute
+    multiplier : float, default=1.5
+        Multiplier for maximum value (max * multiplier)
+    flag_columns : list, optional
+        List of columns for which to create flags (whether value existed before imputation)
+        If None, no flags are created
+    flag_suffix : str, default='_flag'
+        Suffix for flag column names
+    """
+
+    def __init__(
+        self,
+        columns: List[str],
+        multiplier: float = 1.5,
+        flag_columns: Optional[List[str]] = None,
+        flag_suffix: str = "_flag",
+    ):
+
+        self.columns = columns
+        self.multiplier = multiplier
+        self.flag_columns = flag_columns or []
+        self.flag_suffix = flag_suffix
+        self._max_values: Dict[str, float] = {}
+
+    def fit(self, X: pd.DataFrame, y: Optional[Any] = None) -> "MaxMultiplierImputer":
+        """
+        Learn maximum values from training data.
+        """
+        for column in self.columns:
+            if column in X.columns:
+                existing_values = X[column].dropna()
+                if len(existing_values) > 0:
+                    self._max_values[column] = existing_values.max() * self.multiplier
+                else:
+                    self._max_values[column] = 365  # fallback
+
+        return self
+
+    def transform(self, X: pd.DataFrame, y: Optional[Any] = None) -> pd.DataFrame:
+        """
+        Create flags and impute values as max * multiplier.
+        """
+        X_transformed = X.copy()
+
+        # 1. NAJPIERW STWÓRZ FLAGI (przed imputacją!)
+        for column in self.flag_columns:
+            if column in X_transformed.columns:
+                flag_name = f"{column}{self.flag_suffix}"
+                X_transformed[flag_name] = (X_transformed[column].isnull()).astype(int)
+
+        # 2. POTEM IMPUTUJ WARTOŚCI
+        for column in self.columns:
+            if column in X_transformed.columns and column in self._max_values:
+                X_transformed[column] = X_transformed[column].fillna(self._max_values[column])
+
+        return X_transformed
+
+
+class SportsHybridEncoder(BaseEstimator, TransformerMixin):  # type: ignore[misc]
+    """
+    Encodes top N sports as binary features + aggregations for the rest.
+    """
+
+    def __init__(self, sport_columns: Optional[List[str]] = None, top_n: int = 5):
+        self.sport_columns = sport_columns or ["dominant_sport", "first_ticket_sport"]
+        self.top_n = top_n
+        self.sport_mappings_: Dict[str, List[str]] = {}
+
+    def fit(self, X: pd.DataFrame, y: Optional[Any] = None) -> "SportsHybridEncoder":
+
+        for col in self.sport_columns:
+            if col not in X.columns:
+                continue
+
+            all_sports = []
+            for sports_array in X[col]:
+                if isinstance(sports_array, np.ndarray):
+                    all_sports.extend(sports_array.tolist())
+
+            sport_counts = Counter(all_sports)
+            top_sports = [sport for sport, _ in sport_counts.most_common(self.top_n)]
+            self.sport_mappings_[col] = top_sports
+
+            print(f"{col}: top {len(top_sports)} sports selected")
+
+        return self
+
+    def transform(self, X: pd.DataFrame, y: Optional[Any] = None) -> pd.DataFrame:
+        X_result = X.copy()
+
+        for col in self.sport_columns:
+            if col not in X.columns:
+                continue
+
+            prefix = col.replace("_sport", "")
+            top_sports = self.sport_mappings_[col]
+
+            # Binary tylko dla top N sportów
+            for sport in top_sports:
+                safe_name = sport.lower().replace(" ", "_").replace("ł", "l").replace("ą", "a")
+                col_name = f"has_{prefix}_{safe_name}"
+
+                X_result[col_name] = X[col].apply(lambda x, s=sport: 1 if isinstance(x, np.ndarray) and s in x else 0)
+
+            # Agregacje
+            X_result[f"num_{prefix}_sports"] = X[col].apply(lambda x: len(x) if isinstance(x, np.ndarray) else 0)
+
+            X_result[f"num_{prefix}_niche"] = X[col].apply(
+                lambda x: sum(1 for s in x if s not in top_sports) if isinstance(x, np.ndarray) else 0
+            )
+
+            X_result[f"pct_{prefix}_popular"] = X_result.apply(
+                lambda row: (
+                    (row[f"num_{prefix}_sports"] - row[f"num_{prefix}_niche"]) / row[f"num_{prefix}_sports"]
+                    if row[f"num_{prefix}_sports"] > 0
+                    else 0
+                ),
+                axis=1,
+            )
+
+            # Drop oryginał
+            X_result = X_result.drop(col, axis=1)
+
+        return X_result
+
+
+class LabelEncoderTransformer(BaseEstimator, TransformerMixin):  # type: ignore[misc]
+    """
+    Label encoding for categorical variables (for LightGBM).
+    """
+
+    def __init__(self, columns: List[str]):
+        self.columns = columns
+        self.label_encoders_: Dict[str, LabelEncoder] = {}
+
+    def fit(self, X: pd.DataFrame, y: Optional[Any] = None) -> "LabelEncoderTransformer":
+
+        for col in self.columns:
+            if col not in X.columns:
+                continue
+
+            le = LabelEncoder()
+            le.fit(X[col].astype(str))
+            self.label_encoders_[col] = le
+
+            print(f"{col}: {len(le.classes_)} categories")
+
+        return self
+
+    def transform(self, X: pd.DataFrame, y: Optional[Any] = None) -> pd.DataFrame:
+        X_result = X.copy()
+
+        for col in self.columns:
+            if col not in X.columns or col not in self.label_encoders_:
+                continue
+
+            le = self.label_encoders_[col]
+            col_str = X[col].astype(str)
+
+            # Zamień nieznane kategorie na wartość która była w treningu
+            # lub na specjalną wartość -1
+            def safe_transform(val):
+                if val in le.classes_:
+                    return le.transform([val])[0]
+                else:
+                    # Nieznana wartość -> zwróć -1 lub pierwszą znaną klasę
+                    return -1  # LightGBM poradzi sobie z -1 jako "unknown"
+
+            X_result[col] = col_str.apply(safe_transform)
+
+            # Oznacz jako category dla LightGBM
+            X_result[col] = X_result[col].astype("category")
+
+        return X_result
+
+
+class DerivedFeatureCreator(BaseEstimator, TransformerMixin):  # type: ignore[misc]
+    """
+    Creates new columns that are derived from existing columns.
+
+    Parameters
+    ----------
+    derived_features : dict
+        Mapping: {'new_column': ('source_column', operation)}
+        Operation can be:
+        - 'divide_7' - divide by 7
+        - 'divide_30' - divide by 30
+        - float - divide by given number
+    """
+
+    def __init__(self, derived_features: Dict[str, Tuple[str, Any]]):
+        self.derived_features = derived_features
+
+    def fit(self, X: pd.DataFrame, y: Optional[Any] = None) -> "DerivedFeatureCreator":
+        self.is_fitted_ = True
+        return self
+
+    def transform(self, X: pd.DataFrame, y: Optional[Any] = None) -> pd.DataFrame:
+        X_transformed = X.copy()
+
+        for new_col, (source_col, operation) in self.derived_features.items():
+            if source_col not in X_transformed.columns:
+                print(f"WARNING: Source column {source_col!r} not found, skipping {new_col!r}")
+                continue
+
+            if operation == "divide_7":
+                X_transformed[new_col] = X_transformed[source_col] / 7
+            elif operation == "divide_30":
+                X_transformed[new_col] = X_transformed[source_col] / 30
+            elif isinstance(operation, (int, float)):
+                X_transformed[new_col] = X_transformed[source_col] / operation
+            else:
+                print(f"WARNING: Unknown operation {operation!r} for column {new_col!r}")
+
+        return X_transformed
+
+
+def combine_test_data(X: pd.DataFrame, y: pd.Series, y_pred: pd.Series, id_df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Combine test features, targets, predictions, and metadata into single DataFrame.
+
+    Parameters
+    ----------
+    X : pd.DataFrame
+        Features dataframe
+    y : pd.Series
+        Actual target values (remaining_ngr)
+    y_pred : pd.Series
+        Predicted target values
+    id_df : pd.DataFrame
+        DataFrame containing metadata like 'ngr_after_1_year'
+
+    Returns
+    -------
+    pd.DataFrame
+        Combined dataframe with all columns:
+        - All columns from X
+        - 'ngr_after_1_year' from id_df
+        - 'remaining_ngr' (actual values)
+        - 'remaining_ngr_pred' (predicted values)
+
+    Examples
+    --------
+    >>> df = combine_test_data(X, y, y_pred, id_df)
+    >>> df.head()
+    """
+    df = X.copy()
+    df["ngr_after_1_year"] = id_df["ngr_after_1_year"]
+    df["remaining_ngr"] = y
+    df["remaining_ngr_pred"] = y_pred
+
+    return df

utilsds-models/evip_dynamic.py

@@ -0,0 +1,124 @@
+"""
+EVIP dynamic classification metrics.
+
+This module provides recall-based metrics with false-positive budget constraints
+for binary and multi-class premium classification use cases.
+"""
+
+import numpy as np
+
+
+def recall_with_fp_cap(y_true, y_pred, fp_budget_rate=0.03017, alpha=2.0):
+    """
+    Compute recall with a penalty when the false-positive budget is exceeded.
+
+    Standard recall is returned when the number of false positives stays within
+    the allowed budget. Otherwise, recall is scaled down linearly according to
+    how much the budget was exceeded.
+
+    Parameters
+    ----------
+    y_true : array-like of shape (n_samples,)
+        Ground-truth binary labels (0 or 1).
+    y_pred : array-like of shape (n_samples,)
+        Predicted binary labels (0 or 1).
+    fp_budget_rate : float, default=0.03017
+        Maximum allowed false positives as a fraction of the sample size
+        (``fp_budget = fp_budget_rate * n_samples``).
+    alpha : float, default=2.0
+        Penalty multiplier applied to the FP budget excess ratio. The final
+        penalty is capped at 1.0.
+
+    Returns
+    -------
+    float
+        Recall when ``fp <= fp_budget``, otherwise
+        ``recall * (1 - min(alpha * excess_ratio, 1.0))`` where
+        ``excess_ratio = (fp - fp_budget) / fp_budget``.
+
+    Notes
+    -----
+    Recall is computed as ``tp / max(tp + fn, 1)``.
+    """
+    y_true = np.asarray(y_true).ravel()
+    y_pred = np.asarray(y_pred).ravel()
+
+    fp_budget = fp_budget_rate * len(y_true)
+
+    tp = int(((y_pred == 1) & (y_true == 1)).sum())
+    fp = int(((y_pred == 1) & (y_true == 0)).sum())
+    fn = int(((y_pred == 0) & (y_true == 1)).sum())
+
+    recall = tp / max(tp + fn, 1)
+
+    if fp <= fp_budget:
+        return recall
+
+    excess_ratio = (fp - fp_budget) / fp_budget
+    penalty = min(alpha * excess_ratio, 1.0)
+    return recall * (1.0 - penalty)
+
+
+def weighted_premium_recall_with_fp_cap(
+    y_true, y_pred, premium_fpr_budget=0.20, alpha=2.0, w_class_2=2.0
+):
+    """
+    Compute weighted premium recall with a penalty for excessive false-positive rate.
+
+    Classes 1 and 2 are treated as premium targets, with class 2 weighted more
+    heavily in recall. Class 0 is the negative class. A false positive is any
+    sample with true label 0 predicted as premium (class 1 or 2).
+
+    Parameters
+    ----------
+    y_true : array-like of shape (n_samples,)
+        Ground-truth labels (0 = non-premium, 1 or 2 = premium).
+    y_pred : array-like of shape (n_samples,)
+        Predicted labels (0, 1, or 2).
+    premium_fpr_budget : float, default=0.20
+        Maximum allowed false-positive rate among non-premium samples.
+    alpha : float, default=2.0
+        Penalty multiplier applied to the FPR excess ratio. The final penalty
+        is capped at 1.0.
+    w_class_2 : float, default=2.0
+        Weight applied to true positives from class 2 in the weighted recall.
+
+    Returns
+    -------
+    float
+        Weighted premium recall when ``fpr <= premium_fpr_budget``, otherwise
+        ``weighted_recall * (1 - min(alpha * excess_ratio, 1.0))`` where
+        ``excess_ratio = (fpr - premium_fpr_budget) / premium_fpr_budget``.
+        Returns ``0.0`` when there are no premium samples in ``y_true``.
+
+    Notes
+    -----
+    Weighted recall is computed as
+    ``(tp_1 + tp_2 * w_class_2) / (n_1 + n_2 * w_class_2)``.
+    """
+    y_true = np.asarray(y_true).ravel()
+    y_pred = np.asarray(y_pred).ravel()
+
+    tp_1 = int(((y_true == 1) & (y_pred == 1)).sum())
+    tp_2 = int(((y_true == 2) & (y_pred == 2)).sum())
+    n_1 = int((y_true == 1).sum())
+    n_2 = int((y_true == 2).sum())
+
+    max_score = n_1 + n_2 * w_class_2
+    if max_score == 0:
+        return 0.0
+
+    weighted_recall = (tp_1 + tp_2 * w_class_2) / max_score
+
+    is_premium_true = (y_true == 1) | (y_true == 2)
+    is_premium_pred = (y_pred == 1) | (y_pred == 2)
+    fp = int((~is_premium_true & is_premium_pred).sum())
+    n_negative = int((~is_premium_true).sum())
+    fpr = fp / max(n_negative, 1)
+
+    if fpr <= premium_fpr_budget:
+        return weighted_recall
+
+    excess_ratio = (fpr - premium_fpr_budget) / premium_fpr_budget
+    penalty = min(alpha * excess_ratio, 1.0)
+    return weighted_recall * (1.0 - penalty)

utilsds-models/metrics.py

@@ -0,0 +1,179 @@
+"""
+NGR Metrics Calculation Module
+
+This module provides functions for calculating various error metrics
+for NGR (Net Gaming Revenue) predictions with business-optimal weighting.
+"""
+
+from typing import Any, Dict, Optional
+
+import numpy as np
+import pandas as pd
+
+
+def calculate_ngr_metrics(
+    df: pd.DataFrame, late_stage_day: Optional[int] = None, late_stage_correction: Optional[float] = None
+) -> Dict[str, Any]:
+    """
+    Calculate NGR metrics with business-optimal weighting.
+
+    This function computes various error metrics (MAE, MAPE, ME, MPE) with business weights
+    based on days_since_ftd. Optionally applies late-stage corrections to predictions.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing prediction results with columns:
+        - 'days_since_ftd': int, days since first time deposit
+        - 'remaining_ngr': float, actual remaining NGR
+        - 'remaining_ngr_pred': float, predicted remaining NGR
+    late_stage_day : int, optional
+        Day threshold after which to apply correction
+    late_stage_correction : float, optional
+        Correction factor to apply (0.0-1.0) linearly after late_stage_day
+
+    Returns
+    -------
+    dict
+        Dictionary containing calculated metrics:
+        - 'Standard MAE': Mean Absolute Error
+        - 'Standard MAPE (%)': Mean Absolute Percentage Error
+        - 'Standard ME': Mean Error
+        - 'Standard MPE (%)': Mean Percentage Error
+        - 'Business Optimal MAE': Weighted MAE
+        - 'Business Optimal MAPE (%)': Weighted MAPE
+        - 'Business Optimal ME': Weighted ME
+        - 'Business Optimal MPE (%)': Weighted MPE
+        - 'mean_abs_error_by_bin': DataFrame with errors by period
+        - 'mean_values': DataFrame with aggregated values by day
+        - 'weights': Array of business weights by day
+
+    Notes
+    -----
+    Business-optimal weights by day ranges:
+    - Days 1-7: 0.05 (learning period - insufficient data)
+    - Days 8-14: 0.85 (early signals emerging)
+    - Days 15-45: 1.00 (SUPER CRITICAL - optimal intervention window)
+    - Days 46-90: 0.90 (confirmation period - high value)
+    - Days 91-180: 0.60 (established patterns - moderate value)
+    - Days 181-270: 0.40 (mature behavior - operational value)
+    - Days 271+: 0.30 (end-game precision - tactical value)
+
+    Examples
+    --------
+    >>> metrics = calculate_ngr_metrics(
+    ...     df,
+    ...     late_stage_day=320,
+    ...     late_stage_correction=0.95
+    ... )
+    >>> print(f"Business MAE: {metrics['Business Optimal MAE']:.2f}")
+    """
+
+    # Calculate mean values grouped by days_since_ftd
+    mean_values = (
+        df.groupby("days_since_ftd")
+        .agg(
+            {
+                "remaining_ngr": "mean",
+                "remaining_ngr_pred": "mean",
+            }
+        )
+        .reset_index()
+    )
+    mean_values = mean_values[mean_values["days_since_ftd"] < 365]
+
+    # Apply late stage correction if specified
+    if late_stage_day is not None and late_stage_correction is not None:
+        days_array = mean_values["days_since_ftd"].values
+        days_from_start = days_array - late_stage_day
+        max_days = 364 - late_stage_day
+
+        correction_factor = np.where(
+            days_array <= late_stage_day,
+            1.0,  # Before late_stage_day: no changes
+            1.0 - (1.0 - late_stage_correction) * (days_from_start / max_days),  # Linear transition
+        )
+        mean_values["remaining_ngr_pred"] = mean_values["remaining_ngr_pred"] * correction_factor
+
+    days = mean_values["days_since_ftd"].values.astype(np.float64)
+
+    # Business-optimal weighting
+    weights = np.where(
+        days <= 7,
+        0.05,  # Learning period - insufficient data
+        np.where(
+            days <= 14,
+            0.85,  # Early signals emerging
+            np.where(
+                days <= 45,
+                1.00,  # SUPER CRITICAL - optimal intervention window
+                np.where(
+                    days <= 90,
+                    0.90,  # Confirmation period - high value
+                    np.where(
+                        days <= 180,
+                        0.60,  # Established patterns - moderate value
+                        np.where(days <= 270, 0.40, 0.30),  # Mature behavior - operational value
+                    ),
+                ),
+            ),
+        ),
+    )  # End-game precision - tactical value
+
+    abs_errors = np.abs(mean_values["remaining_ngr"] - mean_values["remaining_ngr_pred"])
+    errors = mean_values["remaining_ngr"] - mean_values["remaining_ngr_pred"]
+
+    # Define bins for error analysis by period
+    bins = [0, 7, 14, 45, 90, 180, 270, 364]
+    labels = ["1-7", "8-14", "15-45", "46-90", "91-180", "181-270", "271-364"]
+
+    # Calculate standard metrics
+    business_optimal_tmae = np.sum(abs_errors * weights) / np.sum(weights)
+    business_optimal_me = np.sum(errors * weights) / np.sum(weights)
+    standard_mae = round(np.mean(abs_errors), 4)
+    standard_me = round(np.mean(errors), 4)
+
+    # Calculate percentage-based metrics
+    # Avoid division by zero - use small epsilon for very small values
+    epsilon = 1e-6
+    safe_remaining_ngr = np.where(np.abs(mean_values["remaining_ngr"]) < epsilon, epsilon, mean_values["remaining_ngr"])
+
+    percentage_abs_errors = (
+        np.abs((mean_values["remaining_ngr"] - mean_values["remaining_ngr_pred"]) / safe_remaining_ngr) * 100
+    )
+    errors_percentage = ((mean_values["remaining_ngr"] - mean_values["remaining_ngr_pred"]) / safe_remaining_ngr) * 100
+
+    # Assign each day to a period bin
+    day_bins = pd.cut(mean_values["days_since_ftd"], bins=bins, labels=labels, right=True, include_lowest=True)
+
+    # Calculate mean errors by period
+    mean_abs_error_by_bin = pd.DataFrame(
+        {
+            "bin": labels,
+            "mean_abs_error": [abs_errors[day_bins == label].mean() for label in labels],
+            "mean_error": [errors[day_bins == label].mean() for label in labels],
+            "mape": [percentage_abs_errors[day_bins == label].mean() for label in labels],
+        }
+    )
+
+    # Calculate business-optimal percentage metrics
+    business_optimal_mape = np.sum(percentage_abs_errors * weights) / np.sum(weights)
+    standard_mape = np.mean(percentage_abs_errors)
+
+    business_optimal_mpe = np.sum(errors_percentage * weights) / np.sum(weights)
+    standard_mpe = np.mean(errors_percentage)
+
+    # Return dict with all metrics
+    return {
+        "Standard MAE": standard_mae,
+        "Standard MAPE (%)": round(standard_mape, 1),
+        "Standard ME": standard_me,
+        "Standard MPE (%)": round(standard_mpe, 1),
+        "Business Optimal MAE": round(business_optimal_tmae, 2),
+        "Business Optimal MAPE (%)": round(business_optimal_mape, 1),
+        "Business Optimal ME": round(business_optimal_me, 2),
+        "Business Optimal MPE (%)": round(business_optimal_mpe, 1),
+        "mean_abs_error_by_bin": mean_abs_error_by_bin,
+        "mean_values": mean_values,
+        "weights": weights,
+    }