spforge 0.8.38__py3-none-any.whl → 0.8.39__py3-none-any.whl

spforge/ratings/_base.py

@@ -7,6 +7,7 @@ from abc import abstractmethod
 from typing import Any, Literal
 
 import narwhals.stable.v2 as nw
+import numpy as np
 import polars as pl
 from narwhals.stable.v2 import DataFrame
 from narwhals.stable.v2.typing import IntoFrameT
@@ -149,6 +150,17 @@ class RatingGenerator(FeatureGenerator):
 
         if self.performance_manager:
             if self.performance_manager:
+                # Wire in participation weight column for weighted quantile scaling
+                # This ensures zero-inflated distributions use weights for calibration
+                if (
+                    self.column_names
+                    and self.column_names.participation_weight
+                    and self.column_names.participation_weight in df.columns
+                ):
+                    self.performance_manager.quantile_weight_column = (
+                        self.column_names.participation_weight
+                    )
+
                 ori_perf_values = df[self.performance_manager.ori_performance_column].to_list()
                 df = nw.from_native(self.performance_manager.fit_transform(df))
                 assert (
@@ -165,7 +177,26 @@ class RatingGenerator(FeatureGenerator):
                     "Either transform it manually or set auto_scale_performance to True"
                 )
 
-            if finite_perf.mean() < 0.42 or finite_perf.mean() > 0.58:
+            # Use weighted mean when weighted quantile scaling is active
+            # because the weighted mean is what's calibrated to 0.5
+            if (
+                self.performance_manager
+                and self.performance_manager._using_quantile_scaler
+                and self.performance_manager.quantile_weight_column
+                and self.performance_manager.quantile_weight_column in df.columns
+            ):
+                weights = df[self.performance_manager.quantile_weight_column]
+                valid_mask = perf.is_finite() & weights.is_finite() & (weights > 0)
+                if valid_mask.sum() > 0:
+                    perf_values = perf.filter(valid_mask).to_numpy()
+                    weight_values = weights.filter(valid_mask).to_numpy()
+                    mean_val = float(np.average(perf_values, weights=weight_values))
+                else:
+                    mean_val = float(finite_perf.mean())
+            else:
+                mean_val = float(finite_perf.mean())
+
+            if mean_val < 0.42 or mean_val > 0.58:
                 raise ValueError(
                     f"Mean {self.performance_column} must be between 0.42 and 0.58. "
                     "Either transform it manually or set auto_scale_performance to True"

{spforge-0.8.38.dist-info → spforge-0.8.39.dist-info}/METADATA

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

@@ -50,7 +50,7 @@ spforge/performance_transformers/__init__.py,sha256=J-5olqi1M_BUj3sN1NqAz9s28XAb
 spforge/performance_transformers/_performance_manager.py,sha256=lh7enqYLd1lXj1VTOiK5N880xkil5q1jRsM51fe_K5g,12322
 spforge/performance_transformers/_performances_transformers.py,sha256=nmjJTEH86JjFneWsnSWIYnUXQoUDskOraDO3VtuufIY,20931
 spforge/ratings/__init__.py,sha256=OZVH2Lo6END3n1X8qi4QcyAPlThIwAYwVKCiIuOQSQU,576
-spforge/ratings/_base.py,sha256=Z-VVXWmnzR0O7o2_Q2x2ru_3uiTMpWqKDGQaNBJxCMA,14927
+spforge/ratings/_base.py,sha256=Stl_Y2gjQfS1jq_6CfeRG_e3R5Pei34WETdG6CaibGs,16487
 spforge/ratings/_player_rating.py,sha256=AIpDEl6cZaC3urcY-jFFgUWd4WZ71A33c5mOPfkXdMs,68178
 spforge/ratings/_team_rating.py,sha256=3m90-R2zW0k5EHwjw-83Hacz91fGmxW1LQ8ZUGHlgt4,24970
 spforge/ratings/enums.py,sha256=maG0X4WMQeMVAc2wbceq1an-U-z8moZGeG2BAgfICDA,1809
@@ -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.38.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.39.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
@@ -92,8 +92,8 @@ tests/feature_generator/test_rolling_mean_days.py,sha256=EyOvdJDnmgPfe13uQBOkwo7
 tests/feature_generator/test_rolling_window.py,sha256=_o9oljcAIZ14iI7e8WFeAsfXxILnyqBffit21HOvII4,24378
 tests/hyperparameter_tuning/test_estimator_tuner.py,sha256=iewME41d6LR2aQ0OtohGFtN_ocJUwTeqvs6L0QDmfG4,4413
 tests/hyperparameter_tuning/test_rating_tuner.py,sha256=usjC2ioO_yWRjjNAlRTyMVYheOrCi0kKocmHQHdTmpM,18699
-tests/performance_transformers/test_performance_manager.py,sha256=tHyyyjAotJLtrViWx3j0DaNDqp3nowooMu5Wop7DjBE,24766
-tests/performance_transformers/test_performances_transformers.py,sha256=QyLNzis7yOBsjjclhuYrbZFaSmlTcSAbGVzNvK1B-SU,27817
+tests/performance_transformers/test_performance_manager.py,sha256=Ob4s86hdnR_4RC9ZG3lpB5O4Gysr2cLyTmCsO6uWomc,21244
+tests/performance_transformers/test_performances_transformers.py,sha256=2OLpFgBolU8e-1Pga3hiOGWWHhjYpfx8Qrf9YXiqjUw,20919
 tests/ratings/test_player_rating_generator.py,sha256=1Pkx0H8xJMTeLc2Fu9zJcoDpBWiY2zCVSxuBFJk2uEs,110717
 tests/ratings/test_player_rating_no_mutation.py,sha256=GzO3Hl__5K68DS3uRLefwnbcTJOvBM7cZqww4M21UZM,8493
 tests/ratings/test_ratings_property.py,sha256=ckyfGILXa4tfQvsgyXEzBDNr2DUmHwFRV13N60w66iE,6561
@@ -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.38.dist-info/METADATA,sha256=XXk1_WwD1gWvzRk08OSagsR6_w0qJAjcWX57-fwL9rg,20048
-spforge-0.8.38.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.38.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.38.dist-info/RECORD,,
+spforge-0.8.39.dist-info/METADATA,sha256=njbTQ33nwPOZ71PhHQDxUWZzP4MjSavx8sT-JgK2fio,20048
+spforge-0.8.39.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.39.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.39.dist-info/RECORD,,

tests/performance_transformers/test_performance_manager.py

@@ -437,143 +437,48 @@ class TestZeroInflationHandling:
 
 
 class TestWeightedQuantileScaling:
-    """Tests for weighted quantile scaling in PerformanceManager."""
+    """Test that RatingGenerator wires participation weights to quantile scaling."""
 
-    @pytest.fixture
-    def weighted_zero_inflated_data(self):
-        """Create zero-inflated data where high-weight rows have higher non-zero rate."""
-        np.random.seed(42)
-        n = 1000
-
-        # Create weights (e.g., minutes played)
-        weights = np.random.exponential(scale=20, size=n) + 1
-
-        # High-weight rows have lower zero probability
-        values = []
-        for w in weights:
-            zero_prob = 0.6 - 0.4 * (w / weights.max())
-            if np.random.random() < zero_prob:
-                values.append(0.0)
-            else:
-                values.append(np.random.exponential(scale=2))
-
-        return np.array(values), weights
-
-    @pytest.mark.parametrize("frame", ["pd", "pl"])
-    def test_performance_manager_with_weight_column(self, frame, weighted_zero_inflated_data):
-        """Test that PerformanceManager passes weight column to QuantilePerformanceScaler."""
-        values, weights = weighted_zero_inflated_data
-        df = _make_native_df(frame, {"x": values, "minutes": weights})
-
-        pm = PerformanceManager(
-            features=["x"],
-            transformer_names=None,  # Use defaults, auto-detect zero inflation
-            prefix="performance__",
-            performance_column="perf",
-            zero_inflation_threshold=0.15,
-            quantile_weight_column="minutes",
-        )
-
-        pm.fit(df)
-
-        # Should have switched to quantile scaler
-        assert pm._using_quantile_scaler is True
-        assert isinstance(pm.transformers[-1], QuantilePerformanceScaler)
-        # And should have the weight column set
-        assert pm.transformers[-1].weight_column == "minutes"
-
-    @pytest.mark.parametrize("frame", ["pd", "pl"])
-    def test_weighted_scaling_reduces_weighted_bias(self, frame, weighted_zero_inflated_data):
-        """Test that weighted scaling produces weighted mean closer to 0.5."""
-        values, weights = weighted_zero_inflated_data
-        df = _make_native_df(frame, {"x": values, "minutes": weights})
-
-        # With weighted scaling
-        pm_weighted = PerformanceManager(
-            features=["x"],
-            transformer_names=None,
-            prefix="performance__",
-            performance_column="perf",
-            zero_inflation_threshold=0.15,
-            quantile_weight_column="minutes",
-        )
-
-        result_weighted = pm_weighted.fit_transform(df)
-        result_weighted_nw = nw.from_native(result_weighted)
-        scaled_weighted = result_weighted_nw["performance__perf"].to_numpy()
-
-        # Without weighted scaling
-        pm_unweighted = PerformanceManager(
-            features=["x"],
-            transformer_names=None,
-            prefix="performance__",
-            performance_column="perf",
-            zero_inflation_threshold=0.15,
-            quantile_weight_column=None,  # No weighting
-        )
-
-        result_unweighted = pm_unweighted.fit_transform(df)
-        result_unweighted_nw = nw.from_native(result_unweighted)
-        scaled_unweighted = result_unweighted_nw["performance__perf"].to_numpy()
-
-        # Compute weighted means
-        weighted_mean_of_weighted = np.average(scaled_weighted, weights=weights)
-        weighted_mean_of_unweighted = np.average(scaled_unweighted, weights=weights)
-
-        # Weighted scaling should have weighted mean closer to 0.5
-        assert abs(weighted_mean_of_weighted - 0.5) < abs(weighted_mean_of_unweighted - 0.5), (
-            f"Weighted mean with weighted scaling ({weighted_mean_of_weighted:.4f}) "
-            f"should be closer to 0.5 than without ({weighted_mean_of_unweighted:.4f})"
-        )
-
-    @pytest.mark.parametrize("frame", ["pd", "pl"])
-    def test_performance_weights_manager_with_quantile_weight_column(
-        self, frame, weighted_zero_inflated_data
-    ):
-        """Test that PerformanceWeightsManager also supports quantile_weight_column."""
-        from spforge.performance_transformers._performance_manager import ColumnWeight
-
-        values, weights = weighted_zero_inflated_data
-        df = _make_native_df(frame, {"feat_a": values, "minutes": weights})
+    def test_rating_generator_wires_weight_column(self):
+        """
+        RatingGenerator should automatically wire participation_weight to
+        quantile_weight_column when using auto_scale_performance with zero-inflated data.
+        """
+        from spforge import ColumnNames
+        from spforge.ratings import PlayerRatingGenerator
 
-        column_weights = [ColumnWeight(name="feat_a", weight=1.0)]
-        manager = PerformanceWeightsManager(
-            weights=column_weights,
-            transformer_names=None,
-            prefix="",
-            zero_inflation_threshold=0.15,
-            quantile_weight_column="minutes",
-        )
-
-        manager.fit(df)
-
-        # Should have switched to quantile scaler with weight column
-        assert manager._using_quantile_scaler is True
-        assert manager.transformers[-1].weight_column == "minutes"
-
-    @pytest.mark.parametrize("frame", ["pd", "pl"])
-    def test_weight_column_not_used_when_no_zero_inflation(self, frame):
-        """Test that weight column is not needed when zero inflation is not detected."""
         np.random.seed(42)
-        # Normal distribution - no zero inflation
-        data = np.random.normal(loc=0.5, scale=0.1, size=1000)
-        weights = np.random.exponential(scale=20, size=1000) + 1
-
-        df = _make_native_df(frame, {"x": data, "minutes": weights})
-
-        pm = PerformanceManager(
-            features=["x"],
-            transformer_names=None,
-            prefix="performance__",
-            performance_column="perf",
-            zero_inflation_threshold=0.15,
-            quantile_weight_column="minutes",
+        data = {"player_id": [], "team_id": [], "match_id": [], "start_date": [], "perf": [], "minutes": []}
+
+        for match_idx in range(50):
+            date = f"2024-{(match_idx // 28) + 1:02d}-{(match_idx % 28) + 1:02d}"
+            for team_idx in range(2):
+                for player_idx in range(5):
+                    minutes = min(np.random.exponential(scale=20) + 5, 48)
+                    # Zero-inflated: high-minutes players more likely non-zero
+                    zero_prob = 0.7 - 0.5 * (minutes / 48)
+                    perf = 0.0 if np.random.random() < zero_prob else np.random.exponential(0.1)
+
+                    data["player_id"].append(f"P{team_idx}_{player_idx}")
+                    data["team_id"].append(f"T{team_idx}")
+                    data["match_id"].append(f"M{match_idx}")
+                    data["start_date"].append(date)
+                    data["perf"].append(perf)
+                    data["minutes"].append(minutes / 48)
+
+        cn = ColumnNames(
+            player_id="player_id", team_id="team_id", match_id="match_id",
+            start_date="start_date", update_match_id="match_id", participation_weight="minutes",
         )
 
-        pm.fit(df)
+        gen = PlayerRatingGenerator(performance_column="perf", column_names=cn, auto_scale_performance=True)
+        gen.fit_transform(pl.DataFrame(data))
 
-        # Should NOT have switched to quantile scaler
-        assert pm._using_quantile_scaler is False
+        pm = gen.performance_manager
+        if pm._using_quantile_scaler:
+            assert pm.transformers[-1].weight_column == "minutes", (
+                "RatingGenerator should wire quantile_weight_column to participation_weight"
+            )
 
 
 class TestAutoScalePerformanceBounds:

tests/performance_transformers/test_performances_transformers.py

@@ -554,211 +554,38 @@ class TestQuantilePerformanceScaler:
 
 
 class TestWeightedQuantilePerformanceScaler:
-    """Tests for weighted quantile scaling."""
+    """Tests for weighted quantile scaling algorithm."""
 
-    @pytest.fixture
-    def weighted_zero_inflated_data(self):
-        """Create zero-inflated data where high-weight rows have higher non-zero rate."""
+    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
+    def test_weighted_mean_alignment(self, df_type):
+        """Weighted scaling should produce weighted mean close to 0.5."""
         np.random.seed(42)
         n = 1000
-
-        # Create weights (e.g., minutes played)
-        weights = np.random.exponential(scale=20, size=n) + 1  # 1 to ~100
-
-        # High-weight rows have lower zero probability
-        # This simulates: players with more minutes are more likely to have non-zero stats
+        weights = np.random.exponential(scale=20, size=n) + 1
         values = []
         for w in weights:
-            # Zero probability decreases as weight increases
-            zero_prob = 0.6 - 0.4 * (w / weights.max())  # 0.2 to 0.6
-            if np.random.random() < zero_prob:
-                values.append(0.0)
-            else:
-                values.append(np.random.exponential(scale=2))
-
-        return np.array(values), weights
-
-    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
-    def test_weighted_mean_alignment(self, df_type, weighted_zero_inflated_data):
-        """Test that weighted mean of scaled values is closer to 0.5 with weighted scaling."""
-        values, weights = weighted_zero_inflated_data
-        df = df_type({"performance": values, "weight": weights})
-
-        # Weighted scaler
-        weighted_scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column="weight"
-        )
-        weighted_transformed = weighted_scaler.fit_transform(df)
-
-        if isinstance(weighted_transformed, pd.DataFrame):
-            weighted_scaled = weighted_transformed["performance"].values
-        else:
-            weighted_scaled = weighted_transformed["performance"].to_numpy()
+            zero_prob = 0.6 - 0.4 * (w / weights.max())
+            values.append(0.0 if np.random.random() < zero_prob else np.random.exponential(scale=2))
 
-        # Compute weighted mean
-        weighted_mean = np.average(weighted_scaled, weights=weights)
+        df = df_type({"performance": np.array(values), "weight": weights})
+        scaler = QuantilePerformanceScaler(features=["performance"], prefix="", weight_column="weight")
+        result = scaler.fit_transform(df)
 
-        # Weighted scaling should have weighted mean close to 0.5
-        assert abs(weighted_mean - 0.5) < 0.02, (
-            f"Weighted mean should be close to 0.5, got {weighted_mean}"
-        )
+        scaled = result["performance"].values if isinstance(result, pd.DataFrame) else result["performance"].to_numpy()
+        weighted_mean = np.average(scaled, weights=weights)
+        assert abs(weighted_mean - 0.5) < 0.02
 
     @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
     def test_backward_compatibility_without_weights(self, df_type):
-        """Test that weight_column=None matches original unweighted behavior."""
+        """weight_column=None should match original unweighted behavior."""
         np.random.seed(42)
-        n = 500
-        zeros = np.zeros(200)
-        nonzeros = np.random.exponential(scale=2, size=n - 200)
-        raw = np.concatenate([zeros, nonzeros])
+        raw = np.concatenate([np.zeros(200), np.random.exponential(scale=2, size=300)])
         np.random.shuffle(raw)
-
         df = df_type({"performance": raw})
 
-        # Unweighted scaler (explicitly None)
-        unweighted_scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column=None
-        )
-        unweighted_result = unweighted_scaler.fit_transform(df)
-
-        # Scaler without weight_column argument
-        default_scaler = QuantilePerformanceScaler(features=["performance"], prefix="")
-        default_result = default_scaler.fit_transform(df)
-
-        if isinstance(unweighted_result, pd.DataFrame):
-            unweighted_values = unweighted_result["performance"].values
-            default_values = default_result["performance"].values
-        else:
-            unweighted_values = unweighted_result["performance"].to_numpy()
-            default_values = default_result["performance"].to_numpy()
-
-        # Results should be identical
-        assert np.allclose(unweighted_values, default_values, atol=1e-10)
-
-    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
-    def test_equal_weights_matches_unweighted(self, df_type):
-        """Test that all equal weights produce same result as unweighted."""
-        np.random.seed(42)
-        n = 500
-        zeros = np.zeros(200)
-        nonzeros = np.random.exponential(scale=2, size=n - 200)
-        raw = np.concatenate([zeros, nonzeros])
-        np.random.shuffle(raw)
-        equal_weights = np.ones(n)
-
-        df = df_type({"performance": raw, "weight": equal_weights})
-
-        # Weighted scaler with equal weights
-        weighted_scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column="weight"
-        )
-        weighted_result = weighted_scaler.fit_transform(df)
-
-        # Unweighted scaler
-        unweighted_scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column=None
-        )
-        unweighted_result = unweighted_scaler.fit_transform(df)
-
-        if isinstance(weighted_result, pd.DataFrame):
-            weighted_values = weighted_result["performance"].values
-            unweighted_values = unweighted_result["performance"].values
-        else:
-            weighted_values = weighted_result["performance"].to_numpy()
-            unweighted_values = unweighted_result["performance"].to_numpy()
-
-        # Results should be very close (may differ slightly due to algorithm differences)
-        assert np.allclose(weighted_values, unweighted_values, atol=0.02)
-
-    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
-    def test_weights_with_zeros_excluded(self, df_type):
-        """Test that rows with zero weights are excluded from fitting."""
-        np.random.seed(42)
-        # Create data where zeros have zero weight
-        values = np.array([0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
-        weights = np.array([0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0])  # Zero weight for zeros
-
-        df = df_type({"performance": values, "weight": weights})
+        result1 = QuantilePerformanceScaler(features=["performance"], prefix="", weight_column=None).fit_transform(df)
+        result2 = QuantilePerformanceScaler(features=["performance"], prefix="").fit_transform(df)
 
-        scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column="weight"
-        )
-        scaler.fit(df)
-
-        # Zero proportion should be 0 because zero-weight rows are excluded
-        assert scaler._zero_proportion["performance"] == 0.0
-
-    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
-    def test_weighted_zero_proportion(self, df_type):
-        """Test that zero proportion is computed using weights."""
-        # 3 zeros with weight 10 each = 30
-        # 7 non-zeros with weight 10 each = 70
-        # Weighted zero proportion = 30/100 = 0.3
-        values = np.array([0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
-        weights = np.array([10.0] * 10)
-
-        df = df_type({"performance": values, "weight": weights})
-
-        scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column="weight"
-        )
-        scaler.fit(df)
-
-        assert abs(scaler._zero_proportion["performance"] - 0.3) < 1e-10
-
-    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
-    def test_weighted_zero_proportion_unequal_weights(self, df_type):
-        """Test weighted zero proportion with unequal weights."""
-        # 2 zeros with weight 5 each = 10
-        # 2 non-zeros with weight 15 each = 30
-        # Weighted zero proportion = 10/40 = 0.25
-        values = np.array([0.0, 0.0, 1.0, 2.0])
-        weights = np.array([5.0, 5.0, 15.0, 15.0])
-
-        df = df_type({"performance": values, "weight": weights})
-
-        scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column="weight"
-        )
-        scaler.fit(df)
-
-        assert abs(scaler._zero_proportion["performance"] - 0.25) < 1e-10
-
-    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
-    def test_monotonicity_preserved_with_weights(self, df_type, weighted_zero_inflated_data):
-        """Test that monotonicity is preserved with weighted scaling."""
-        values, weights = weighted_zero_inflated_data
-        df = df_type({"performance": values, "weight": weights})
-
-        scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column="weight"
-        )
-        transformed = scaler.fit_transform(df)
-
-        if isinstance(transformed, pd.DataFrame):
-            scaled = transformed["performance"].values
-        else:
-            scaled = transformed["performance"].to_numpy()
-
-        # Check monotonicity
-        order = np.argsort(values)
-        sorted_scaled = scaled[order]
-        assert np.all(np.diff(sorted_scaled) >= -1e-10)
-
-    @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
-    def test_bounded_zero_one_with_weights(self, df_type, weighted_zero_inflated_data):
-        """Test that output is bounded [0, 1] with weighted scaling."""
-        values, weights = weighted_zero_inflated_data
-        df = df_type({"performance": values, "weight": weights})
-
-        scaler = QuantilePerformanceScaler(
-            features=["performance"], prefix="", weight_column="weight"
-        )
-        transformed = scaler.fit_transform(df)
-
-        if isinstance(transformed, pd.DataFrame):
-            scaled = transformed["performance"].values
-        else:
-            scaled = transformed["performance"].to_numpy()
-
-        assert np.all((scaled >= 0) & (scaled <= 1))
+        v1 = result1["performance"].values if isinstance(result1, pd.DataFrame) else result1["performance"].to_numpy()
+        v2 = result2["performance"].values if isinstance(result2, pd.DataFrame) else result2["performance"].to_numpy()
+        assert np.allclose(v1, v2, atol=1e-10)