spforge 0.8.17__tar.gz → 0.8.19__tar.gz

{spforge-0.8.17/spforge.egg-info → spforge-0.8.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.17
+Version: 0.8.19
 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.17 → spforge-0.8.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.17"
+version = "0.8.19"
 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.17 → spforge-0.8.19}/spforge/autopipeline.py

@@ -236,6 +236,7 @@ class AutoPipeline(BaseEstimator):
         estimator_features: list[str],
         predictor_transformers: list[PredictorTransformer] | None = None,
         granularity: list[str] | None = None,
+        aggregation_weight: str | None = None,
         filters: list[Filter] | None = None,
         scale_features: bool = False,
         categorical_handling: CategoricalHandling = "auto",
@@ -250,6 +251,7 @@ class AutoPipeline(BaseEstimator):
         self.estimator_features = estimator_features
         self.feature_names = estimator_features  # Internal compat
         self.granularity = granularity or []
+        self.aggregation_weight = aggregation_weight
         self.predictor_transformers = predictor_transformers
         self.estimator = estimator
         self.filters = filters or []
@@ -326,6 +328,10 @@ class AutoPipeline(BaseEstimator):
         # Add granularity columns
         context.extend(self.granularity)
 
+        # Add aggregation weight column
+        if self.aggregation_weight:
+            context.append(self.aggregation_weight)
+
         # Add filter columns
         self._filter_feature_names = []
         for f in self.filters:
@@ -492,7 +498,11 @@ class AutoPipeline(BaseEstimator):
         pre = PreprocessorToDataFrame(pre_raw)
 
         est = (
-            GroupByEstimator(self.estimator, granularity=[f"{c}" for c in self.granularity])
+            GroupByEstimator(
+                self.estimator,
+                granularity=[f"{c}" for c in self.granularity],
+                aggregation_weight=self.aggregation_weight,
+            )
             if do_groupby
             else self.estimator
         )

{spforge-0.8.17 → spforge-0.8.19}/spforge/estimator/_group_by_estimator.py

@@ -10,10 +10,16 @@ from spforge.transformers._other_transformer import GroupByReducer
 
 
 class GroupByEstimator(BaseEstimator):
-    def __init__(self, estimator: Any, granularity: list[str] | None = None):
+    def __init__(
+        self,
+        estimator: Any,
+        granularity: list[str] | None = None,
+        aggregation_weight: str | None = None,
+    ):
         self.estimator = estimator
         self.granularity = granularity or []
-        self._reducer = GroupByReducer(self.granularity)
+        self.aggregation_weight = aggregation_weight
+        self._reducer = GroupByReducer(self.granularity, aggregation_weight=aggregation_weight)
         self._est = None
 
     def __sklearn_is_fitted__(self):
@@ -22,7 +28,9 @@ class GroupByEstimator(BaseEstimator):
     @nw.narwhalify
     def fit(self, X: IntoFrameT, y: Any, sample_weight: np.ndarray | None = None):
         X = X.to_pandas()
-        self._reducer = GroupByReducer(self.granularity)
+        # Backwards compatibility: old pickled objects may not have aggregation_weight
+        agg_weight = getattr(self, "aggregation_weight", None)
+        self._reducer = GroupByReducer(self.granularity, aggregation_weight=agg_weight)
         X_red = nw.from_native(self._reducer.fit_transform(X))
         y_red, sw_red = self._reducer.reduce_y(X, y, sample_weight=sample_weight)
 

{spforge-0.8.17 → spforge-0.8.19}/spforge/hyperparameter_tuning/__init__.py

@@ -7,6 +7,7 @@ from spforge.hyperparameter_tuning._default_search_spaces import (
     get_default_search_space,
     get_default_student_t_search_space,
     get_default_team_rating_search_space,
+    get_full_player_rating_search_space,
 )
 from spforge.hyperparameter_tuning._tuner import (
     EstimatorHyperparameterTuner,
@@ -28,4 +29,5 @@ __all__ = [
     "get_default_team_rating_search_space",
     "get_default_student_t_search_space",
     "get_default_search_space",
+    "get_full_player_rating_search_space",
 ]

{spforge-0.8.17 → spforge-0.8.19}/spforge/hyperparameter_tuning/_default_search_spaces.py

@@ -128,6 +128,7 @@ def get_default_player_rating_search_space() -> dict[str, ParamSpec]:
     Default search space for PlayerRatingGenerator.
 
     Focuses on core parameters that have the most impact on performance.
+    Excludes performance_predictor and team-based start rating params.
 
     Returns:
         Dictionary mapping parameter names to ParamSpec objects
@@ -163,10 +164,6 @@ def get_default_player_rating_search_space() -> dict[str, ParamSpec]:
         "use_off_def_split": ParamSpec(
             param_type="bool",
         ),
-        "performance_predictor": ParamSpec(
-            param_type="categorical",
-            choices=["difference", "mean", "ignore_opponent"],
-        ),
         "start_league_quantile": ParamSpec(
             param_type="float",
             low=0.05,
@@ -177,24 +174,46 @@ def get_default_player_rating_search_space() -> dict[str, ParamSpec]:
             low=40,
             high=500,
         ),
-        "start_team_rating_subtract": ParamSpec(
-            param_type="float",
-            low=0.0,
-            high=200.0,
-        ),
-        "start_team_weight": ParamSpec(
-            param_type="float",
-            low=0.0,
-            high=1.0,
-        ),
-        "start_min_match_count_team_rating": ParamSpec(
-            param_type="int",
-            low=1,
-            high=10,
-        ),
     }
 
 
+def get_full_player_rating_search_space() -> dict[str, ParamSpec]:
+    """
+    Full search space for PlayerRatingGenerator including all tunable parameters.
+
+    Includes performance_predictor and team-based start rating parameters.
+    Use this when you want to tune all parameters.
+
+    Returns:
+        Dictionary mapping parameter names to ParamSpec objects
+    """
+    base = get_default_player_rating_search_space()
+    base.update(
+        {
+            "performance_predictor": ParamSpec(
+                param_type="categorical",
+                choices=["difference", "mean", "ignore_opponent"],
+            ),
+            "start_team_rating_subtract": ParamSpec(
+                param_type="float",
+                low=0.0,
+                high=200.0,
+            ),
+            "start_team_weight": ParamSpec(
+                param_type="float",
+                low=0.0,
+                high=1.0,
+            ),
+            "start_min_match_count_team_rating": ParamSpec(
+                param_type="int",
+                low=1,
+                high=10,
+            ),
+        }
+    )
+    return base
+
+
 def get_default_team_rating_search_space() -> dict[str, ParamSpec]:
     """
     Default search space for TeamRatingGenerator.
@@ -235,10 +254,6 @@ def get_default_team_rating_search_space() -> dict[str, ParamSpec]:
         "use_off_def_split": ParamSpec(
             param_type="bool",
         ),
-        "performance_predictor": ParamSpec(
-            param_type="categorical",
-            choices=["difference", "mean", "ignore_opponent"],
-        ),
     }
 
 

{spforge-0.8.17 → spforge-0.8.19}/spforge/hyperparameter_tuning/_tuner.py

@@ -91,6 +91,9 @@ class RatingHyperparameterTuner:
         scorer: BaseScorer,
         direction: Literal["minimize", "maximize"],
         param_search_space: dict[str, ParamSpec] | None = None,
+        param_ranges: dict[str, tuple[float | int, float | int]] | None = None,
+        exclude_params: list[str] | None = None,
+        fixed_params: dict[str, Any] | None = None,
         n_trials: int = 50,
         n_jobs: int = 1,
         storage: str | None = None,
@@ -109,6 +112,14 @@ class RatingHyperparameterTuner:
             scorer: Scorer for evaluation (must have score(df) -> float | dict)
             direction: "minimize" or "maximize"
             param_search_space: Custom search space (merges with defaults if provided)
+            param_ranges: Easy range override for float/int params. Maps param name to
+                (low, high) tuple. Preserves param_type and log scale from defaults.
+                Example: {"confidence_weight": (0.2, 1.0)}
+            exclude_params: List of param names to exclude from tuning entirely.
+                Example: ["performance_predictor", "use_off_def_split"]
+            fixed_params: Parameters to fix at specific values (not tuned).
+                These values are applied to the rating generator each trial.
+                Example: {"performance_predictor": "mean"}
             n_trials: Number of optimization trials
             n_jobs: Number of parallel jobs (1 = sequential)
             storage: Optuna storage URL (e.g., "sqlite:///optuna.db") for persistence
@@ -123,6 +134,9 @@ class RatingHyperparameterTuner:
         self.scorer = scorer
         self.direction = direction
         self.custom_search_space = param_search_space
+        self.param_ranges = param_ranges
+        self.exclude_params = exclude_params or []
+        self.fixed_params = fixed_params or {}
         self.n_trials = n_trials
         self.n_jobs = n_jobs
         self.storage = storage
@@ -196,6 +210,9 @@ class RatingHyperparameterTuner:
         try:
             copied_gen = copy.deepcopy(self.rating_generator)
 
+            for param_name, param_value in self.fixed_params.items():
+                setattr(copied_gen, param_name, param_value)
+
             trial_params = self._suggest_params(trial, search_space)
 
             for param_name, param_value in trial_params.items():
@@ -243,18 +260,54 @@ class RatingHyperparameterTuner:
         defaults: dict[str, ParamSpec],
     ) -> dict[str, ParamSpec]:
         """
-        Merge custom search space with defaults (custom takes precedence).
+        Merge custom search space with defaults.
+
+        Priority order (highest to lowest):
+        1. exclude_params - removes param entirely
+        2. fixed_params - removes from search (applied separately)
+        3. custom (param_search_space) - full ParamSpec override
+        4. param_ranges - updates only low/high bounds
+        5. defaults - base search space
 
         Args:
             custom: Custom search space (may be None)
             defaults: Default search space
 
         Returns:
-            Merged search space
+            Merged search space (excludes fixed_params, those are applied separately)
         """
         merged = defaults.copy()
+
+        if self.param_ranges:
+            for param_name, (low, high) in self.param_ranges.items():
+                if param_name not in merged:
+                    raise ValueError(
+                        f"param_ranges contains unknown parameter: '{param_name}'. "
+                        f"Available parameters: {list(merged.keys())}"
+                    )
+                existing = merged[param_name]
+                if existing.param_type not in ("float", "int"):
+                    raise ValueError(
+                        f"param_ranges can only override float/int parameters. "
+                        f"'{param_name}' is {existing.param_type}."
+                    )
+                merged[param_name] = ParamSpec(
+                    param_type=existing.param_type,
+                    low=low,
+                    high=high,
+                    log=existing.log,
+                    step=existing.step,
+                )
+
         if custom:
             merged.update(custom)
+
+        for param_name in self.exclude_params:
+            merged.pop(param_name, None)
+
+        for param_name in self.fixed_params:
+            merged.pop(param_name, None)
+
         return merged
 
     @staticmethod

{spforge-0.8.17 → spforge-0.8.19}/spforge/transformers/_other_transformer.py

@@ -8,8 +8,9 @@ from sklearn.base import BaseEstimator, TransformerMixin
 
 
 class GroupByReducer(BaseEstimator, TransformerMixin):
-    def __init__(self, granularity: list[str]):
+    def __init__(self, granularity: list[str], aggregation_weight: str | None = None):
         self.granularity = granularity
+        self.aggregation_weight = aggregation_weight
 
     @nw.narwhalify
     def fit(self, X: IntoFrameT, y: Any = None):
@@ -26,18 +27,47 @@ class GroupByReducer(BaseEstimator, TransformerMixin):
             raise ValueError("Could not find granularity columns in dataframe %s", self.granularity)
 
         non_keys = [c for c in df.columns if c not in keys]
-        num_cols = [c for c in non_keys if pd.api.types.is_numeric_dtype(df[c])]
+        schema = df.schema
+        num_cols = [c for c in non_keys if schema[c].is_numeric()]
         other_cols = [c for c in non_keys if c not in num_cols]
 
         aggs: list[nw.Expr] = []
 
+        # Backwards compatibility: old pickled objects may not have aggregation_weight
+        weight_col = getattr(self, "aggregation_weight", None)
+        has_weight = weight_col and weight_col in df.columns
+
         for c in num_cols:
-            aggs.append(nw.col(c).mean().alias(c))
+            if c == weight_col:
+                aggs.append(nw.col(c).sum().alias(c))
+            elif has_weight:
+                aggs.append((nw.col(c) * nw.col(weight_col)).sum().alias(f"__{c}_weighted_sum"))
+                aggs.append(nw.col(c).mean().alias(f"__{c}_fallback"))
+            else:
+                aggs.append(nw.col(c).mean().alias(c))
 
         for c in other_cols:
             aggs.append(nw.col(c).first().alias(c))
 
+        if has_weight:
+            aggs.append(nw.col(weight_col).sum().alias("__weight_sum"))
+
         out = df.group_by(keys).agg(aggs)
+
+        if has_weight:
+            weighted_cols = [c for c in num_cols if c != weight_col]
+            for c in weighted_cols:
+                out = out.with_columns(
+                    nw.when((~nw.col("__weight_sum").is_null()) & (nw.col("__weight_sum") != 0))
+                    .then(nw.col(f"__{c}_weighted_sum") / nw.col("__weight_sum"))
+                    .otherwise(nw.col(f"__{c}_fallback"))
+                    .alias(c)
+                )
+            drop_cols = [f"__{c}_weighted_sum" for c in weighted_cols]
+            drop_cols += [f"__{c}_fallback" for c in weighted_cols]
+            drop_cols.append("__weight_sum")
+            out = out.drop(drop_cols)
+
         return out
 
     @nw.narwhalify
@@ -59,12 +89,12 @@ class GroupByReducer(BaseEstimator, TransformerMixin):
         if sample_weight is not None:
             df = df.with_columns(nw.lit(sample_weight).alias("__sw"))
 
-        y_is_numeric = df.select(nw.col("__y")).schema["__y"].is_numeric()
+        y_uniques = df.group_by(keys).agg(nw.col("__y").n_unique().alias("__y_nunique"))
+        non_uniform = y_uniques.filter(nw.col("__y_nunique") > 1)
+        if len(non_uniform) > 0:
+            raise ValueError("Target (y) must be uniform within each granularity group")
 
-        if y_is_numeric:
-            agg_exprs = [nw.col("__y").mean().alias("__y")]
-        else:
-            agg_exprs = [nw.col("__y").first().alias("__y")]
+        agg_exprs = [nw.col("__y").first().alias("__y")]
 
         if sample_weight is not None:
             agg_exprs.append(nw.col("__sw").sum().alias("__sw"))

{spforge-0.8.17 → spforge-0.8.19/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.17
+Version: 0.8.19
 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.17 → spforge-0.8.19}/tests/end_to_end/test_nba_player_ratings_hyperparameter_tuning.py

@@ -96,12 +96,8 @@ def test_nba_player_ratings_hyperparameter_tuning__workflow_completes(
         "confidence_value_denom",
         "confidence_max_sum",
         "use_off_def_split",
-        "performance_predictor",
-        "start_team_weight",
         "start_league_quantile",
         "start_min_count_for_percentiles",
-        "start_min_match_count_team_rating",
-        "start_team_rating_subtract",
     }
     assert set(result.best_params.keys()) == expected_params
 

{spforge-0.8.17 → spforge-0.8.19}/tests/hyperparameter_tuning/test_rating_tuner.py

@@ -454,3 +454,160 @@ def test_param_spec__categorical_requires_choices():
 
     with pytest.raises(ValueError, match="requires choices"):
         spec.suggest(trial, "test_param")
+
+
+def test_param_ranges__overrides_bounds(
+    player_rating_generator, cross_validator, scorer, sample_player_df_pd
+):
+    """Test that param_ranges overrides low/high bounds while preserving param_type."""
+    tuner = RatingHyperparameterTuner(
+        rating_generator=player_rating_generator,
+        cross_validator=cross_validator,
+        scorer=scorer,
+        direction="minimize",
+        param_ranges={
+            "confidence_weight": (0.2, 0.3),
+        },
+        n_trials=3,
+        show_progress_bar=False,
+    )
+
+    result = tuner.optimize(sample_player_df_pd)
+
+    assert "confidence_weight" in result.best_params
+    assert 0.2 <= result.best_params["confidence_weight"] <= 0.3
+
+
+def test_exclude_params__removes_from_search(
+    player_rating_generator, cross_validator, scorer, sample_player_df_pd
+):
+    """Test that exclude_params removes parameters from search space."""
+    tuner = RatingHyperparameterTuner(
+        rating_generator=player_rating_generator,
+        cross_validator=cross_validator,
+        scorer=scorer,
+        direction="minimize",
+        exclude_params=["use_off_def_split", "confidence_weight"],
+        n_trials=3,
+        show_progress_bar=False,
+    )
+
+    result = tuner.optimize(sample_player_df_pd)
+
+    assert "use_off_def_split" not in result.best_params
+    assert "confidence_weight" not in result.best_params
+    assert "rating_change_multiplier_offense" in result.best_params
+
+
+def test_fixed_params__applies_values_without_tuning(
+    player_rating_generator, cross_validator, scorer, sample_player_df_pd
+):
+    """Test that fixed_params sets values without including in search space."""
+    tuner = RatingHyperparameterTuner(
+        rating_generator=player_rating_generator,
+        cross_validator=cross_validator,
+        scorer=scorer,
+        direction="minimize",
+        fixed_params={"use_off_def_split": False},
+        n_trials=3,
+        show_progress_bar=False,
+    )
+
+    result = tuner.optimize(sample_player_df_pd)
+
+    assert "use_off_def_split" not in result.best_params
+
+
+def test_param_ranges__unknown_param_raises_error(
+    player_rating_generator, cross_validator, scorer, sample_player_df_pd
+):
+    """Test that param_ranges with unknown param raises ValueError."""
+    tuner = RatingHyperparameterTuner(
+        rating_generator=player_rating_generator,
+        cross_validator=cross_validator,
+        scorer=scorer,
+        direction="minimize",
+        param_ranges={"nonexistent_param": (0.0, 1.0)},
+        n_trials=3,
+        show_progress_bar=False,
+    )
+
+    with pytest.raises(ValueError, match="unknown parameter"):
+        tuner.optimize(sample_player_df_pd)
+
+
+def test_param_ranges__non_numeric_param_raises_error(
+    player_rating_generator, cross_validator, scorer, sample_player_df_pd
+):
+    """Test that param_ranges on non-float/int param raises ValueError."""
+    tuner = RatingHyperparameterTuner(
+        rating_generator=player_rating_generator,
+        cross_validator=cross_validator,
+        scorer=scorer,
+        direction="minimize",
+        param_ranges={"use_off_def_split": (0, 1)},
+        n_trials=3,
+        show_progress_bar=False,
+    )
+
+    with pytest.raises(ValueError, match="can only override float/int"):
+        tuner.optimize(sample_player_df_pd)
+
+
+def test_combined_api__param_ranges_exclude_fixed(
+    player_rating_generator, cross_validator, scorer, sample_player_df_pd
+):
+    """Test using param_ranges, exclude_params, and fixed_params together."""
+    tuner = RatingHyperparameterTuner(
+        rating_generator=player_rating_generator,
+        cross_validator=cross_validator,
+        scorer=scorer,
+        direction="minimize",
+        param_ranges={
+            "confidence_weight": (0.2, 1.0),
+            "rating_change_multiplier_offense": (10.0, 150.0),
+        },
+        exclude_params=["start_league_quantile"],
+        fixed_params={"use_off_def_split": False},
+        n_trials=3,
+        show_progress_bar=False,
+    )
+
+    result = tuner.optimize(sample_player_df_pd)
+
+    assert 0.2 <= result.best_params["confidence_weight"] <= 1.0
+    assert 10.0 <= result.best_params["rating_change_multiplier_offense"] <= 150.0
+    assert "start_league_quantile" not in result.best_params
+    assert "use_off_def_split" not in result.best_params
+
+
+def test_default_search_space__excludes_performance_predictor_and_team_start(
+    player_rating_generator,
+):
+    """Test that performance_predictor and team start params are not in default search space."""
+    from spforge.hyperparameter_tuning._default_search_spaces import (
+        get_default_search_space,
+    )
+
+    defaults = get_default_search_space(player_rating_generator)
+
+    assert "performance_predictor" not in defaults
+    assert "start_team_rating_subtract" not in defaults
+    assert "start_team_weight" not in defaults
+    assert "start_min_match_count_team_rating" not in defaults
+
+
+def test_full_player_rating_search_space__includes_all_params():
+    """Test that full search space includes performance_predictor and team start params."""
+    from spforge.hyperparameter_tuning._default_search_spaces import (
+        get_full_player_rating_search_space,
+    )
+
+    full = get_full_player_rating_search_space()
+
+    assert "performance_predictor" in full
+    assert "start_team_rating_subtract" in full
+    assert "start_team_weight" in full
+    assert "start_min_match_count_team_rating" in full
+    assert "rating_change_multiplier_offense" in full
+    assert "confidence_weight" in full

{spforge-0.8.17 → spforge-0.8.19}/tests/test_autopipeline.py

@@ -328,7 +328,18 @@ def test_infer_categorical_from_feature_names_when_only_numeric_features_given(d
     assert any(c.startswith("cat") for c in cap.fit_columns)
 
 
-def test_granularity_groups_rows_before_estimator_fit_and_predict(df_reg):
+def test_granularity_groups_rows_before_estimator_fit_and_predict(frame):
+    df_pd = pd.DataFrame(
+        {
+            "gameid": ["g1", "g1", "g2", "g2", "g3", "g3"],
+            "num1": [1.0, 2.0, np.nan, 4.0, 5.0, 6.0],
+            "num2": [10.0, 20.0, 30.0, 40.0, np.nan, 60.0],
+            "cat1": ["a", "b", "a", None, "b", "c"],
+            "y": [1.0, 1.0, 2.0, 2.0, 3.0, 3.0],
+        }
+    )
+    df = df_pd if frame == "pd" else pl.from_pandas(df_pd)
+
     model = AutoPipeline(
         estimator=CaptureEstimator(),
         estimator_features=["gameid", "num1", "num2", "cat1"],
@@ -339,16 +350,16 @@ def test_granularity_groups_rows_before_estimator_fit_and_predict(df_reg):
         remainder="drop",
     )
 
-    X = _select(df_reg, ["gameid", "num1", "num2", "cat1"])
-    y = _col(df_reg, "y")
+    X = _select(df, ["gameid", "num1", "num2", "cat1"])
+    y = _col(df, "y")
     model.fit(X, y=y)
 
     inner = _inner_estimator(model)
 
-    if isinstance(df_reg, pl.DataFrame):
-        n_groups = df_reg.select(pl.col("gameid").n_unique()).item()
+    if isinstance(df, pl.DataFrame):
+        n_groups = df.select(pl.col("gameid").n_unique()).item()
     else:
-        n_groups = df_reg["gameid"].nunique()
+        n_groups = df["gameid"].nunique()
 
     assert inner.fit_shape[0] == n_groups
 
@@ -724,9 +735,10 @@ def test_feature_importance_names__granularity_uses_deep_feature_names():
             "gameid": ["g1", "g1", "g2", "g2"],
             "num1": [1.0, 2.0, 3.0, 4.0],
             "num2": [10.0, 20.0, 30.0, 40.0],
+            "y": [1.0, 1.0, 2.0, 2.0],
         }
     )
-    y = pd.Series([1.0, 2.0, 3.0, 4.0], name="y")
+    y = df["y"]
 
     model = AutoPipeline(
         estimator=RandomForestRegressor(n_estimators=5, random_state=42),
@@ -745,3 +757,127 @@ def test_feature_importance_names__granularity_uses_deep_feature_names():
     assert list(names.keys()) == list(inner.feature_names_in_)
     assert "gameid" not in names
     assert "const_pred" in names
+
+
+@pytest.mark.parametrize("frame", ["pd", "pl"])
+def test_granularity_with_aggregation_weight__features_weighted(frame):
+    df_pd = pd.DataFrame(
+        {
+            "gameid": ["g1", "g1", "g2", "g2"],
+            "num1": [10.0, 30.0, 20.0, 40.0],
+            "weight": [0.25, 0.75, 0.5, 0.5],
+            "y": [1.0, 1.0, 2.0, 2.0],
+        }
+    )
+    df = df_pd if frame == "pd" else pl.from_pandas(df_pd)
+
+    cap = CaptureEstimator()
+    model = AutoPipeline(
+        estimator=cap,
+        estimator_features=["num1"],
+        granularity=["gameid"],
+        aggregation_weight="weight",
+        remainder="drop",
+    )
+
+    X = _select(df, ["gameid", "num1", "weight"])
+    y = _col(df, "y")
+    model.fit(X, y=y)
+
+    inner = _inner_estimator(model)
+    assert inner.fit_shape[0] == 2
+
+    preds = model.predict(X)
+    assert preds.shape[0] == len(X)
+
+
+@pytest.mark.parametrize("frame", ["pd", "pl"])
+def test_granularity_aggregation_weight__weighted_mean_correct(frame):
+    df_pd = pd.DataFrame(
+        {
+            "gameid": ["g1", "g1"],
+            "num1": [10.0, 30.0],
+            "weight": [0.25, 0.75],
+            "y": [1.0, 1.0],
+        }
+    )
+    df = df_pd if frame == "pd" else pl.from_pandas(df_pd)
+
+    from spforge.transformers._other_transformer import GroupByReducer
+
+    reducer = GroupByReducer(granularity=["gameid"], aggregation_weight="weight")
+    transformed = reducer.fit_transform(df)
+
+    if frame == "pl":
+        num1_val = transformed["num1"].to_list()[0]
+    else:
+        num1_val = transformed["num1"].iloc[0]
+
+    expected = (10.0 * 0.25 + 30.0 * 0.75) / (0.25 + 0.75)
+    assert abs(num1_val - expected) < 1e-6
+
+
+@pytest.mark.parametrize("frame", ["pd", "pl"])
+def test_reduce_y_raises_when_target_not_uniform_per_group(frame):
+    df_pd = pd.DataFrame(
+        {
+            "gameid": ["g1", "g1"],
+            "num1": [10.0, 30.0],
+        }
+    )
+    df = df_pd if frame == "pd" else pl.from_pandas(df_pd)
+
+    from spforge.transformers._other_transformer import GroupByReducer
+
+    reducer = GroupByReducer(granularity=["gameid"])
+
+    y = np.array([1.0, 2.0])
+    with pytest.raises(ValueError, match="Target.*must be uniform"):
+        reducer.reduce_y(df, y)
+
+
+@pytest.mark.parametrize("frame", ["pd", "pl"])
+def test_reduce_y_works_when_target_uniform_per_group(frame):
+    df_pd = pd.DataFrame(
+        {
+            "gameid": ["g1", "g1", "g2", "g2"],
+            "num1": [10.0, 30.0, 20.0, 40.0],
+        }
+    )
+    df = df_pd if frame == "pd" else pl.from_pandas(df_pd)
+
+    from spforge.transformers._other_transformer import GroupByReducer
+
+    reducer = GroupByReducer(granularity=["gameid"])
+
+    y = np.array([1.0, 1.0, 2.0, 2.0])
+    y_out, _ = reducer.reduce_y(df, y)
+
+    assert len(y_out) == 2
+    assert set(y_out) == {1.0, 2.0}
+
+
+@pytest.mark.parametrize("frame", ["pd", "pl"])
+def test_aggregation_weight_sums_weight_column(frame):
+    df_pd = pd.DataFrame(
+        {
+            "gameid": ["g1", "g1"],
+            "num1": [10.0, 30.0],
+            "weight": [0.25, 0.75],
+            "y": [1.0, 1.0],
+        }
+    )
+    df = df_pd if frame == "pd" else pl.from_pandas(df_pd)
+
+    from spforge.transformers._other_transformer import GroupByReducer
+
+    reducer = GroupByReducer(granularity=["gameid"], aggregation_weight="weight")
+    transformed = reducer.fit_transform(df)
+
+    if frame == "pl":
+        weight_val = transformed["weight"].to_list()[0]
+    else:
+        weight_val = transformed["weight"].iloc[0]
+
+    expected = 0.25 + 0.75
+    assert abs(weight_val - expected) < 1e-6