spforge 0.8.29__py3-none-any.whl → 0.8.30__py3-none-any.whl

spforge/data_structures.py

@@ -12,6 +12,8 @@ class ColumnNames:
     position: str | None = None
     participation_weight: str | None = None
     projected_participation_weight: str | None = None
+    defense_participation_weight: str | None = None
+    projected_defense_participation_weight: str | None = None
     update_match_id: str | None = None
     parent_team_id: str | None = None
     team_players_playing_time: str | None = None
@@ -81,6 +83,8 @@ class MatchPerformance:
     performance_value: float | None
     participation_weight: float | None
     projected_participation_weight: float
+    defense_participation_weight: float | None = None
+    projected_defense_participation_weight: float | None = None
     team_players_playing_time: dict[str, float] | None = None
     opponent_players_playing_time: dict[str, float] | None = None
 

spforge/ratings/_player_rating.py

@@ -39,6 +39,8 @@ from spforge.feature_generator._utils import to_polars
 PLAYER_STATS = "__PLAYER_STATS"
 _SCALED_PW = "__scaled_participation_weight__"
 _SCALED_PPW = "__scaled_projected_participation_weight__"
+_SCALED_DPW = "__scaled_defense_participation_weight__"
+_SCALED_PDPW = "__scaled_projected_defense_participation_weight__"
 
 
 class PlayerRatingGenerator(RatingGenerator):
@@ -186,6 +188,8 @@ class PlayerRatingGenerator(RatingGenerator):
         self.auto_scale_participation_weights = bool(auto_scale_participation_weights)
         self._participation_weight_max: float | None = None
         self._projected_participation_weight_max: float | None = None
+        self._defense_participation_weight_max: float | None = None
+        self._projected_defense_participation_weight_max: float | None = None
 
         self._player_off_ratings: dict[str, PlayerRating] = {}
         self._player_def_ratings: dict[str, PlayerRating] = {}
@@ -233,8 +237,11 @@ class PlayerRatingGenerator(RatingGenerator):
             eps = 1e-6
             return min_val < -eps or max_val > (1.0 + eps)
 
-        if _out_of_bounds(cn.participation_weight) or _out_of_bounds(
-            cn.projected_participation_weight
+        if (
+            _out_of_bounds(cn.participation_weight)
+            or _out_of_bounds(cn.projected_participation_weight)
+            or _out_of_bounds(cn.defense_participation_weight)
+            or _out_of_bounds(cn.projected_defense_participation_weight)
         ):
             self.scale_participation_weights = True
             logging.warning(
@@ -289,6 +296,25 @@ class PlayerRatingGenerator(RatingGenerator):
         elif self._participation_weight_max is not None:
             self._projected_participation_weight_max = self._participation_weight_max
 
+        if cn.defense_participation_weight and cn.defense_participation_weight in df.columns:
+            q_val = pl_df[cn.defense_participation_weight].quantile(0.99, "linear")
+            if q_val is not None:
+                self._defense_participation_weight_max = float(q_val)
+        elif self._participation_weight_max is not None:
+            self._defense_participation_weight_max = self._participation_weight_max
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+        ):
+            q_val = pl_df[cn.projected_defense_participation_weight].quantile(0.99, "linear")
+            if q_val is not None:
+                self._projected_defense_participation_weight_max = float(q_val)
+        elif self._defense_participation_weight_max is not None:
+            self._projected_defense_participation_weight_max = self._defense_participation_weight_max
+        elif self._projected_participation_weight_max is not None:
+            self._projected_defense_participation_weight_max = self._projected_participation_weight_max
+
     def _scale_participation_weight_columns(self, df: pl.DataFrame) -> pl.DataFrame:
         """Create internal scaled participation weight columns without mutating originals."""
         if not self.scale_participation_weights:
@@ -321,6 +347,32 @@ class PlayerRatingGenerator(RatingGenerator):
                 .alias(_SCALED_PPW)
             )
 
+        if (
+            cn.defense_participation_weight
+            and cn.defense_participation_weight in df.columns
+            and self._defense_participation_weight_max is not None
+            and self._defense_participation_weight_max > 0
+        ):
+            denom = float(self._defense_participation_weight_max)
+            df = df.with_columns(
+                (pl.col(cn.defense_participation_weight) / denom)
+                .clip(0.0, 1.0)
+                .alias(_SCALED_DPW)
+            )
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+            and self._projected_defense_participation_weight_max is not None
+            and self._projected_defense_participation_weight_max > 0
+        ):
+            denom = float(self._projected_defense_participation_weight_max)
+            df = df.with_columns(
+                (pl.col(cn.projected_defense_participation_weight) / denom)
+                .clip(0.0, 1.0)
+                .alias(_SCALED_PDPW)
+            )
+
         return df
 
     def _get_participation_weight_col(self) -> str:
@@ -339,7 +391,9 @@ class PlayerRatingGenerator(RatingGenerator):
 
     def _remove_internal_scaled_columns(self, df: pl.DataFrame) -> pl.DataFrame:
         """Remove internal scaled columns before returning."""
-        cols_to_drop = [c for c in [_SCALED_PW, _SCALED_PPW] if c in df.columns]
+        cols_to_drop = [
+            c for c in [_SCALED_PW, _SCALED_PPW, _SCALED_DPW, _SCALED_PDPW] if c in df.columns
+        ]
         if cols_to_drop:
             df = df.drop(cols_to_drop)
         return df
@@ -554,7 +608,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     def_change = (
                         (def_perf - float(pred_def))
                         * mult_def
-                        * float(pre_player.match_performance.participation_weight)
+                        * float(pre_player.match_performance.defense_participation_weight)
                     )
 
                 if math.isnan(off_change) or math.isnan(def_change):
@@ -648,7 +702,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     def_change = (
                         (def_perf - float(pred_def))
                         * mult_def
-                        * float(pre_player.match_performance.participation_weight)
+                        * float(pre_player.match_performance.defense_participation_weight)
                     )
 
                 if math.isnan(off_change) or math.isnan(def_change):
@@ -922,6 +976,19 @@ class PlayerRatingGenerator(RatingGenerator):
         if _SCALED_PPW in df.columns:
             player_stat_cols.append(_SCALED_PPW)
 
+        if cn.defense_participation_weight and cn.defense_participation_weight in df.columns:
+            player_stat_cols.append(cn.defense_participation_weight)
+        if _SCALED_DPW in df.columns:
+            player_stat_cols.append(_SCALED_DPW)
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+        ):
+            player_stat_cols.append(cn.projected_defense_participation_weight)
+        if _SCALED_PDPW in df.columns:
+            player_stat_cols.append(_SCALED_PDPW)
+
         if cn.position and cn.position in df.columns:
             player_stat_cols.append(cn.position)
 
@@ -1041,6 +1108,28 @@ class PlayerRatingGenerator(RatingGenerator):
                 projected_participation_weight = participation_weight
             projected_participation_weights.append(projected_participation_weight)
 
+            # Use scaled defense participation weight if available, otherwise default to participation_weight
+            if _SCALED_DPW in team_player:
+                defense_participation_weight = team_player.get(_SCALED_DPW, participation_weight)
+            elif cn.defense_participation_weight:
+                defense_participation_weight = team_player.get(
+                    cn.defense_participation_weight, participation_weight
+                )
+            else:
+                defense_participation_weight = participation_weight
+
+            # Use scaled projected defense participation weight if available
+            if _SCALED_PDPW in team_player:
+                projected_defense_participation_weight = team_player.get(
+                    _SCALED_PDPW, defense_participation_weight
+                )
+            elif cn.projected_defense_participation_weight:
+                projected_defense_participation_weight = team_player.get(
+                    cn.projected_defense_participation_weight, defense_participation_weight
+                )
+            else:
+                projected_defense_participation_weight = defense_participation_weight
+
             perf_val = (
                 float(team_player[self.performance_column])
                 if (
@@ -1061,6 +1150,8 @@ class PlayerRatingGenerator(RatingGenerator):
                 performance_value=perf_val,
                 projected_participation_weight=projected_participation_weight,
                 participation_weight=participation_weight,
+                defense_participation_weight=defense_participation_weight,
+                projected_defense_participation_weight=projected_defense_participation_weight,
                 team_players_playing_time=team_playing_time,
                 opponent_players_playing_time=opponent_playing_time,
             )
@@ -1296,6 +1387,22 @@ class PlayerRatingGenerator(RatingGenerator):
                         ppw = pw
                     proj_w.append(float(ppw))
 
+                    # Use scaled defense participation weight if available
+                    if _SCALED_DPW in tp:
+                        dpw = tp.get(_SCALED_DPW, pw)
+                    elif cn.defense_participation_weight:
+                        dpw = tp.get(cn.defense_participation_weight, pw)
+                    else:
+                        dpw = pw
+
+                    # Use scaled projected defense participation weight if available
+                    if _SCALED_PDPW in tp:
+                        pdpw = tp.get(_SCALED_PDPW, dpw)
+                    elif cn.projected_defense_participation_weight:
+                        pdpw = tp.get(cn.projected_defense_participation_weight, dpw)
+                    else:
+                        pdpw = dpw
+
                     team_playing_time = self._get_players_playing_time(
                         tp, cn.team_players_playing_time
                     )
@@ -1307,6 +1414,8 @@ class PlayerRatingGenerator(RatingGenerator):
                         performance_value=get_perf_value(tp),
                         projected_participation_weight=ppw,
                         participation_weight=pw,
+                        defense_participation_weight=dpw,
+                        projected_defense_participation_weight=pdpw,
                         team_players_playing_time=team_playing_time,
                         opponent_players_playing_time=opponent_playing_time,
                     )

{spforge-0.8.29.dist-info → spforge-0.8.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.29
+Version: 0.8.30
 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.29.dist-info → spforge-0.8.30.dist-info}/RECORD

@@ -16,7 +16,7 @@ examples/nba/data/utils.py,sha256=41hxLQ1d6ZgBEcHa5MI0-fG5KbsRi07cclMPQZM95ek,50
 spforge/__init__.py,sha256=8vZhy7XUpzqWkVKpXqwqOLDkQlNytRhyf4qjwObfXgU,468
 spforge/autopipeline.py,sha256=rZ6FhJxcgNLvtr3hTVkEiW4BiorgXxADThfMuQ42orE,29866
 spforge/base_feature_generator.py,sha256=RbD00N6oLCQQcEb_VF5wbwZztl-X8k9B0Wlaj9Os1iU,668
-spforge/data_structures.py,sha256=k82v5r79vl0_FAVvsxVF9Nbzb5FoHqVrlHZlEXGc5gQ,7298
+spforge/data_structures.py,sha256=AltcyPvEI2qLuk43qwnljTj-QZzLMw1UEL6-lWQvqLQ,7530
 spforge/features_generator_pipeline.py,sha256=n8vzZKqXNFcFRDWZhllnkhAh5NFXdOD3FEIOpHcay8E,8208
 spforge/utils.py,sha256=2RlivUtMX5wQWpFVUyFfexDJE0wV6uZ4dnNzvoDmVhI,2644
 spforge/cross_validator/__init__.py,sha256=1QHgTFIZ73EZ_MgJlUKimxdUmB7MFaOEy6jsUs6V0T0,134
@@ -51,7 +51,7 @@ spforge/performance_transformers/_performance_manager.py,sha256=WmjmlMEnq7y75MiI
 spforge/performance_transformers/_performances_transformers.py,sha256=0lxuWjAfWBRXRgQsNJHjw3P-nlTtHBu4_bOVdoy7hq4,15536
 spforge/ratings/__init__.py,sha256=OZVH2Lo6END3n1X8qi4QcyAPlThIwAYwVKCiIuOQSQU,576
 spforge/ratings/_base.py,sha256=ne4BRrYFPqMirdFPVnyDN44wjFQwOQgWoUXu_59xgWE,14687
-spforge/ratings/_player_rating.py,sha256=y6i7vv3RcNpYmcjBelu_lJXQmZQ4kOgswXeRwyc7ieY,61621
+spforge/ratings/_player_rating.py,sha256=0VZYTWdoZoxPpw1UhTsRxlwMJjBAGNr2EdGOQkT2BpE,67097
 spforge/ratings/_team_rating.py,sha256=3m90-R2zW0k5EHwjw-83Hacz91fGmxW1LQ8ZUGHlgt4,24970
 spforge/ratings/enums.py,sha256=s7z_RcZS6Nlgfa_6tasO8_IABZJwywexe7sep9DJBgo,1739
 spforge/ratings/league_identifier.py,sha256=_KDUKOwoNU6RNFKE5jju4eYFGVNGBdJsv5mhNvMakfc,6019
@@ -71,7 +71,7 @@ spforge/transformers/_other_transformer.py,sha256=w2a7Wnki3vJe4GAkSa4kealw0GILIo
 spforge/transformers/_predictor.py,sha256=2sE6gfVrilXzPVcBurSrtqHw33v2ljygQcEYXt9LhZc,3119
 spforge/transformers/_simple_transformer.py,sha256=zGUFNQYMeoDSa2CoQejQNiNmKCBN5amWTvyOchiUHj0,5660
 spforge/transformers/_team_ratio_predictor.py,sha256=g8_bR53Yyv0iNCtol1O9bgJSeZcIco_AfbQuUxQJkeY,6884
-spforge-0.8.29.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.30.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/test_autopipeline.py,sha256=7cNAn-nmGolfyfk3THh9IKcHZfRA-pLYC_xAyMg-No4,26863
 tests/test_autopipeline_context.py,sha256=IuRUY4IA6uMObvbl2pXSaXO2_tl3qX6wEbTZY0dkTMI,1240
 tests/test_feature_generator_pipeline.py,sha256=CK0zVL8PfTncy3RmG9i-YpgwjOIV7yJhV7Q44tbetI8,19020
@@ -94,7 +94,7 @@ tests/hyperparameter_tuning/test_estimator_tuner.py,sha256=iewME41d6LR2aQ0OtohGF
 tests/hyperparameter_tuning/test_rating_tuner.py,sha256=usjC2ioO_yWRjjNAlRTyMVYheOrCi0kKocmHQHdTmpM,18699
 tests/performance_transformers/test_performance_manager.py,sha256=gjuuV_hb27kCo_kUecPKG3Cbot2Gqis1W3kw2A4ovS4,10690
 tests/performance_transformers/test_performances_transformers.py,sha256=A-tGiCx7kXrj1cVj03Bc7prOeZ1_Ryz8YFx9uj3eK6w,11064
-tests/ratings/test_player_rating_generator.py,sha256=gfNb2OcxGbs9MrPNZj_ShBk5VwLHNxXliUF9bsrvHcE,96836
+tests/ratings/test_player_rating_generator.py,sha256=F4mW7J4djkFpt0GgORIfVz0jKegfGNwPqGtXp44VOSc,100762
 tests/ratings/test_player_rating_no_mutation.py,sha256=GzO3Hl__5K68DS3uRLefwnbcTJOvBM7cZqww4M21UZM,8493
 tests/ratings/test_ratings_property.py,sha256=ckyfGILXa4tfQvsgyXEzBDNr2DUmHwFRV13N60w66iE,6561
 tests/ratings/test_team_rating_generator.py,sha256=SqQcfckNmJJc99feCdnmkNYDape-p69e92Dp8Vzpu2w,101156
@@ -108,7 +108,7 @@ tests/transformers/test_other_transformer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 tests/transformers/test_predictor_transformer.py,sha256=N1aBYLjN3ldpYZLwjih_gTFYSMitrZu-PNK78W6RHaQ,6877
 tests/transformers/test_simple_transformer.py,sha256=wWR0qjLb_uS4HXrJgGdiqugOY1X7kwd1_OPS02IT2b8,4676
 tests/transformers/test_team_ratio_predictor.py,sha256=fOUP_JvNJi-3kom3ZOs1EdG0I6Z8hpLpYKNHu1eWtOw,8562
-spforge-0.8.29.dist-info/METADATA,sha256=T-ruW0iWlC_xBOBpvNf6lBI55ErBY5clTPmkahthCLI,20048
-spforge-0.8.29.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.29.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.29.dist-info/RECORD,,
+spforge-0.8.30.dist-info/METADATA,sha256=DHqd51r8ONs36cHM0-CaWQJW_4QIKmX5MDNvl-2xTfo,20048
+spforge-0.8.30.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.30.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.30.dist-info/RECORD,,

tests/ratings/test_player_rating_generator.py

@@ -2710,3 +2710,114 @@ def test_ignore_opponent_predictor_reference_rating_set_correctly(base_cn):
     assert gen5._performance_predictor._reference_rating == 1200.0, (
         f"Expected hardcoded start rating 1200.0 to take precedence, got {gen5._performance_predictor._reference_rating}"
     )
+
+
+def test_separate_offense_defense_participation_weights(base_cn):
+    """Test that offense and defense use separate participation weights.
+
+    When participation_weight represents offensive activity (e.g., shots attempted),
+    using it for both offense and defense updates creates bias. This test verifies
+    that defense_participation_weight is used for defensive rating updates.
+    """
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        participation_weight="shots_attempted",
+        defense_participation_weight="minutes",
+    )
+
+    # Create a scenario where a high-volume shooter (many shots) faces a low-volume shooter
+    # The high-volume shooter should have larger offensive updates but equal defensive updates
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.6, 0.4, 0.5, 0.5],  # Varying performance values
+            "shots_attempted": [10.0, 10.0, 10.0, 10.0],  # Same offensive activity
+            "minutes": [30.0, 30.0, 30.0, 30.0],  # Same defensive activity
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        rating_change_multiplier_offense=50,
+        rating_change_multiplier_defense=50,
+    )
+
+    result = gen.fit_transform(df)
+
+    # Verify that the defense_participation_weight column is present in the data
+    assert "minutes" in df.columns
+
+    # All players performed equally (0.5) with equal participation weights,
+    # so ratings should be symmetric
+    assert "P1" in gen._player_off_ratings
+    assert "P1" in gen._player_def_ratings
+
+    # Now test with different participation weights for offense vs defense
+    df2 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M2", "M2", "M2", "M2"],
+            "dt": ["2024-01-02"] * 4,
+            "perf": [0.6, 0.4, 0.5, 0.5],
+            "shots_attempted": [20.0, 5.0, 10.0, 10.0],  # P1 shoots much more
+            "minutes": [30.0, 30.0, 30.0, 30.0],  # But all play same minutes
+        }
+    )
+
+    result2 = gen.fit_transform(df2)
+
+    # P1 should have larger offensive rating changes due to high shots_attempted
+    # but equal defensive rating changes due to equal minutes played
+    p1_off = gen._player_off_ratings["P1"]
+    p2_off = gen._player_off_ratings["P2"]
+    p1_def = gen._player_def_ratings["P1"]
+    p2_def = gen._player_def_ratings["P2"]
+
+    # Both players have same games_played count for defense
+    assert p1_def.games_played == p2_def.games_played
+
+    # Verify that ratings were updated
+    assert p1_off.games_played > 0
+    assert p2_off.games_played > 0
+
+
+@pytest.mark.parametrize("library", ["polars", "pandas"])
+def test_defense_participation_weight_backwards_compatibility(base_cn, library):
+    """Test that when defense_participation_weight is not set, it defaults to participation_weight."""
+    import pandas as pd
+
+    df_data = {
+        "pid": ["P1", "P2", "P3", "P4"],
+        "tid": ["T1", "T1", "T2", "T2"],
+        "mid": ["M1", "M1", "M1", "M1"],
+        "dt": ["2024-01-01"] * 4,
+        "perf": [0.6, 0.4, 0.5, 0.5],
+        "pw": [1.0, 0.5, 0.8, 0.8],
+    }
+
+    if library == "polars":
+        df = pl.DataFrame(df_data)
+    else:
+        df = pd.DataFrame(df_data)
+
+    # When defense_participation_weight is None, it should default to participation_weight
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        auto_scale_performance=True,
+    )
+
+    result = gen.fit_transform(df)
+
+    # Should work without errors
+    assert result is not None
+    assert len(gen._player_off_ratings) > 0
+    assert len(gen._player_def_ratings) > 0