spforge 0.8.25__tar.gz → 0.8.26__tar.gz

{spforge-0.8.25/spforge.egg-info → spforge-0.8.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.25
+Version: 0.8.26
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file

{spforge-0.8.25 → spforge-0.8.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.25"
+version = "0.8.26"
 description = "A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data."
 readme = "README.md"
 requires-python = ">=3.11"

{spforge-0.8.25 → spforge-0.8.26}/spforge/scorer/_score.py

@@ -263,6 +263,7 @@ class BaseScorer(ABC):
         validation_column: str | None,
         filters: list[Filter] | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
@@ -274,6 +275,7 @@ class BaseScorer(ABC):
             If set, the scorer will be calculated only once the values of the validation column are equal to 1
         :param filters: The filters to apply before calculating
         :param aggregation_level: The columns to group by before calculating the score (e.g., group from game-player to game-team)
+        :param aggregation_method: Aggregation methods for pred/target when aggregation_level is set.
         :param granularity: The columns to calculate separate scores for each unique combination (e.g., different scores for each team)
         """
         self.target = target
@@ -289,28 +291,59 @@ class BaseScorer(ABC):
                 )
             )
         self.aggregation_level = aggregation_level
+        self.aggregation_method = aggregation_method
         self.granularity = granularity
         self.compare_to_naive = compare_to_naive
         self.naive_granularity = naive_granularity
 
+    def _resolve_aggregation_method(self, key: str) -> Any:
+        if self.aggregation_method is None:
+            return "sum"
+        method = self.aggregation_method.get(key)
+        if method is None:
+            return "sum"
+        return method
+
+    def _build_aggregation_expr(self, df: IntoFrameT, col: str, method: Any) -> Any:
+        if isinstance(method, tuple):
+            if len(method) != 2 or method[0] != "weighted_mean":
+                raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+            weight_col = method[1]
+            if weight_col not in df.columns:
+                raise ValueError(
+                    f"Aggregation weight column '{weight_col}' not found in dataframe columns."
+                )
+            weighted_sum = (nw.col(col) * nw.col(weight_col)).sum()
+            weight_total = nw.col(weight_col).sum()
+            return (weighted_sum / weight_total).alias(col)
+
+        if method == "sum":
+            return nw.col(col).sum().alias(col)
+        if method == "mean":
+            return nw.col(col).mean().alias(col)
+        if method == "first":
+            return nw.col(col).first().alias(col)
+        raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+
     def _apply_aggregation_level(self, df: IntoFrameT) -> IntoFrameT:
         """Apply aggregation_level grouping if set"""
         if self.aggregation_level:
-            # Determine aggregation method based on column types
-            # For numeric columns, use sum; for others, use first or mean
-            agg_exprs = []
-            for col in [self.pred_column, self.target]:
-                # Try to determine if numeric
-                try:
-                    # Use sum for aggregation
-                    agg_exprs.append(nw.col(col).sum().alias(col))
-                except Exception:
-                    # Fallback to mean or first
-                    agg_exprs.append(nw.col(col).mean().alias(col))
-
+            pred_method = self._resolve_aggregation_method("pred")
+            target_method = self._resolve_aggregation_method("target")
+            agg_exprs = [
+                self._build_aggregation_expr(df, self.pred_column, pred_method),
+                self._build_aggregation_expr(df, self.target, target_method),
+            ]
             df = df.group_by(self.aggregation_level).agg(agg_exprs)
         return df
 
+    @narwhals.narwhalify
+    def aggregate(self, df: IntoFrameT) -> IntoFrameT:
+        df = apply_filters(df, self.filters)
+        if not hasattr(df, "to_native"):
+            df = nw.from_native(df)
+        return self._apply_aggregation_level(df)
+
     def _get_granularity_groups(self, df: IntoFrameT) -> list[tuple]:
         """Get list of granularity tuples from dataframe"""
         if not self.granularity:
@@ -345,6 +378,7 @@ class PWMSE(BaseScorer):
         target: str,
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         labels: list[int] | None = None,
@@ -357,6 +391,7 @@ class PWMSE(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -454,12 +489,7 @@ class PWMSE(BaseScorer):
 
                 pass
             else:
-                df = df.group_by(self.aggregation_level).agg(
-                    [
-                        nw.col(self.pred_column).mean().alias(self.pred_column),
-                        nw.col(self.target).mean().alias(self.target),
-                    ]
-                )
+                df = self._apply_aggregation_level(df)
 
         if self.granularity:
             results = {}
@@ -517,6 +547,7 @@ class MeanBiasScorer(BaseScorer):
         target: str,
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         labels: list[int] | None = None,
@@ -540,6 +571,7 @@ class MeanBiasScorer(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -582,12 +614,7 @@ class MeanBiasScorer(BaseScorer):
 
         # Apply aggregation_level if set
         if self.aggregation_level:
-            df = df.group_by(self.aggregation_level).agg(
-                [
-                    nw.col(self.pred_column_name).sum().alias(self.pred_column_name),
-                    nw.col(self.target).sum().alias(self.target),
-                ]
-            )
+            df = self._apply_aggregation_level(df)
             # After group_by, ensure df is still a Narwhals DataFrame
             if not hasattr(df, "to_native"):
                 df = nw.from_native(df)
@@ -658,6 +685,7 @@ class SklearnScorer(BaseScorer):
         target: str,
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         params: dict[str, Any] = None,
@@ -679,6 +707,7 @@ class SklearnScorer(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -756,12 +785,7 @@ class SklearnScorer(BaseScorer):
             )
 
         if self.aggregation_level:
-            df = df.group_by(self.aggregation_level).agg(
-                [
-                    nw.col(self.pred_column_name).sum().alias(self.pred_column_name),
-                    nw.col(self.target).sum().alias(self.target),
-                ]
-            )
+            df = self._apply_aggregation_level(df)
             if not hasattr(df, "to_native"):
                 df = nw.from_native(df)
 
@@ -798,6 +822,7 @@ class ProbabilisticMeanBias(BaseScorer):
         class_column_name: str = "classes",
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         compare_to_naive: bool = False,
@@ -810,6 +835,7 @@ class ProbabilisticMeanBias(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -817,6 +843,49 @@ class ProbabilisticMeanBias(BaseScorer):
             naive_granularity=naive_granularity,
         )
 
+    def _aggregate_pandas_series(
+        self, df: pd.DataFrame, col: str, method: Any
+    ) -> pd.Series:
+        grouped = df.groupby(self.aggregation_level, dropna=False)
+        if isinstance(method, tuple):
+            if len(method) != 2 or method[0] != "weighted_mean":
+                raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+            weight_col = method[1]
+            if weight_col not in df.columns:
+                raise ValueError(
+                    f"Aggregation weight column '{weight_col}' not found in dataframe columns."
+                )
+            return grouped.apply(
+                lambda g: (g[col] * g[weight_col]).sum() / g[weight_col].sum()
+            )
+
+        if method == "sum":
+            return grouped[col].sum()
+        if method == "mean":
+            return grouped[col].mean()
+        if method == "first":
+            return grouped[col].first()
+        raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+
+    def _aggregate_pandas(self, df: pd.DataFrame) -> pd.DataFrame:
+        if not self.aggregation_level:
+            return df
+        pred_method = self._resolve_aggregation_method("pred")
+        target_method = self._resolve_aggregation_method("target")
+        agg_df = pd.DataFrame(
+            {
+                self.pred_column: self._aggregate_pandas_series(
+                    df, self.pred_column, pred_method
+                ),
+                self.target: self._aggregate_pandas_series(df, self.target, target_method),
+                self.class_column_name: df.groupby(self.aggregation_level, dropna=False)[
+                    self.class_column_name
+                ].first(),
+            }
+        )
+        agg_df.reset_index(inplace=True)
+        return agg_df
+
     def _calculate_score_for_group(self, df: pd.DataFrame) -> float:
         """Calculate score for a single group (used for granularity)"""
         df = df.copy()
@@ -948,13 +1017,7 @@ class ProbabilisticMeanBias(BaseScorer):
 
         # Apply aggregation_level if set
         if self.aggregation_level:
-            df = (
-                df.groupby(self.aggregation_level)
-                .agg(
-                    {self.pred_column: "mean", self.target: "mean", self.class_column_name: "first"}
-                )
-                .reset_index()
-            )
+            df = self._aggregate_pandas(df)
 
         # If granularity is set, calculate separate scores per group
         if self.granularity:
@@ -995,6 +1058,7 @@ class OrdinalLossScorer(BaseScorer):
         classes: list[int],
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         labels: list[int] | None = None,
@@ -1006,6 +1070,7 @@ class OrdinalLossScorer(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -1102,14 +1167,10 @@ class OrdinalLossScorer(BaseScorer):
         if not hasattr(df, "to_native"):
             df = nw.from_native(df)
 
-        df_native = df.to_native()
-        df_pl = pl.DataFrame(df_native) if isinstance(df_native, pd.DataFrame) else df_native
-
         # Filter out null and NaN targets
-        before = len(df_pl)
-        target_col = pl.col(self.target)
-        df_pl = df_pl.filter(target_col.is_not_null() & target_col.is_not_nan())
-        after = len(df_pl)
+        before = len(df)
+        df = _filter_nulls_and_nans(df, self.target)
+        after = len(df)
         if before != after:
             _logger.info(
                 "OrdinalLossScorer: Dropped %d rows with NaN target (%d → %d)",
@@ -1119,12 +1180,12 @@ class OrdinalLossScorer(BaseScorer):
             )
 
         if self.aggregation_level:
-            df_pl = df_pl.group_by(self.aggregation_level).agg(
-                [
-                    pl.col(self.pred_column).mean().alias(self.pred_column),
-                    pl.col(self.target).mean().alias(self.target),
-                ]
-            )
+            df = self._apply_aggregation_level(df)
+
+        df_native = df.to_native()
+        df_pl = pl.DataFrame(df_native) if isinstance(df_native, pd.DataFrame) else df_native
+        if df_pl.is_empty():
+            return {} if self.granularity else 0.0
 
         if self.granularity:
             results = {}
@@ -1197,6 +1258,7 @@ class ThresholdEventScorer(BaseScorer):
         threshold_rounding: str = "ceil",
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list["Filter"] | None = None,
         compare_to_naive: bool = False,
@@ -1207,6 +1269,7 @@ class ThresholdEventScorer(BaseScorer):
             target=self._EVENT_COL,
             pred_column=dist_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -1227,6 +1290,7 @@ class ThresholdEventScorer(BaseScorer):
             target=self._EVENT_COL,
             pred_column=self._P_EVENT_COL,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=None,
             validation_column=validation_column,

{spforge-0.8.25 → spforge-0.8.26/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.25
+Version: 0.8.26
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file

{spforge-0.8.25 → spforge-0.8.26}/tests/scorer/test_score_aggregation_granularity.py

@@ -21,6 +21,16 @@ def create_dataframe(df_type, data: dict):
     return df_type(data)
 
 
+def to_pandas_df(df):
+    if hasattr(df, "to_native"):
+        df = df.to_native()
+    if isinstance(df, pd.DataFrame):
+        return df
+    if isinstance(df, pl.DataFrame):
+        return df.to_pandas()
+    raise TypeError(f"Unsupported dataframe type: {type(df)}")
+
+
 # ============================================================================
 # Aggregation Level Tests
 # ============================================================================
@@ -104,6 +114,65 @@ def test_pwmse_aggregation_level(df_type):
     assert score >= 0
 
 
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pd.DataFrame])
+def test_aggregate_returns_grouped_frame(df_type):
+    """aggregate returns filtered, grouped dataframe with default sum behavior"""
+    df = create_dataframe(
+        df_type,
+        {
+            "game_id": [1, 1, 1, 1],
+            "player_id": [1, 2, 3, 4],
+            "team_id": [1, 1, 2, 2],
+            "pred": [0.5, 0.6, 0.3, 0.4],
+            "target": [0, 1, 0, 1],
+        },
+    )
+
+    scorer = MeanBiasScorer(
+        pred_column="pred", target="target", aggregation_level=["game_id", "team_id"]
+    )
+    aggregated = to_pandas_df(scorer.aggregate(df))
+
+    assert len(aggregated) == 2
+    team1 = aggregated[aggregated["team_id"] == 1].iloc[0]
+    team2 = aggregated[aggregated["team_id"] == 2].iloc[0]
+    assert abs(team1["pred"] - 1.1) < 1e-10
+    assert abs(team1["target"] - 1.0) < 1e-10
+    assert abs(team2["pred"] - 0.7) < 1e-10
+    assert abs(team2["target"] - 1.0) < 1e-10
+
+
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pd.DataFrame])
+def test_weighted_mean_aggregation_method(df_type):
+    """Weighted mean aggregation uses provided weight column"""
+    df = create_dataframe(
+        df_type,
+        {
+            "game_id": [1, 1, 1],
+            "team_id": [1, 1, 1],
+            "pred": [0.4, 0.6, 0.9],
+            "target": [0.5, 0.7, 0.2],
+            "attempts": [10, 20, 30],
+        },
+    )
+
+    scorer = MeanBiasScorer(
+        pred_column="pred",
+        target="target",
+        aggregation_level=["game_id", "team_id"],
+        aggregation_method={
+            "pred": ("weighted_mean", "attempts"),
+            "target": ("weighted_mean", "attempts"),
+        },
+    )
+
+    score = scorer.score(df)
+    expected_pred = (0.4 * 10 + 0.6 * 20 + 0.9 * 30) / 60
+    expected_target = (0.5 * 10 + 0.7 * 20 + 0.2 * 30) / 60
+    expected = expected_pred - expected_target
+    assert abs(score - expected) < 1e-10
+
+
 # ============================================================================
 # Granularity Tests (Separate Scores Per Group)
 # ============================================================================