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

spforge/performance_transformers/_performance_manager.py

@@ -89,6 +89,7 @@ class PerformanceManager(BaseEstimator, TransformerMixin):
         min_value: float = 0.0,
         max_value: float = 1.0,
         zero_inflation_threshold: float = 0.15,
+        quantile_weight_column: str | None = None,
     ):
         self.features = features
         self.prefix = prefix
@@ -106,6 +107,7 @@ class PerformanceManager(BaseEstimator, TransformerMixin):
         self.min_value = min_value
         self.max_value = max_value
         self.zero_inflation_threshold = zero_inflation_threshold
+        self.quantile_weight_column = quantile_weight_column
 
         self.transformers = create_performance_scalers_transformers(
             transformer_names=self.transformer_names,
@@ -150,6 +152,7 @@ class PerformanceManager(BaseEstimator, TransformerMixin):
                             QuantilePerformanceScaler(
                                 features=prefixed_features,
                                 prefix="",
+                                weight_column=self.quantile_weight_column,
                             )
                         ]
                         break
@@ -214,6 +217,7 @@ class PerformanceWeightsManager(PerformanceManager):
         prefix: str = "performance__",
         return_all_features: bool = False,
         zero_inflation_threshold: float = 0.15,
+        quantile_weight_column: str | None = None,
     ):
         self.weights = weights
         self.return_all_features = return_all_features
@@ -227,6 +231,7 @@ class PerformanceWeightsManager(PerformanceManager):
             min_value=min_value,
             performance_column=performance_column,
             zero_inflation_threshold=zero_inflation_threshold,
+            quantile_weight_column=quantile_weight_column,
         )
 
     @nw.narwhalify

spforge/performance_transformers/_performances_transformers.py

@@ -432,6 +432,9 @@ class QuantilePerformanceScaler(BaseEstimator, TransformerMixin):
     - Non-zeros → uniform on (π, 1) via empirical CDF
 
     Fast: O(n log n) for fit, O(n) for transform.
+
+    If weight_column is provided, weighted quantiles are computed so that
+    the scaling respects participation weights (e.g., minutes played).
     """
 
     def __init__(
@@ -440,11 +443,13 @@ class QuantilePerformanceScaler(BaseEstimator, TransformerMixin):
         zero_threshold: float = 1e-10,
         n_quantiles: int = 1000,
         prefix: str = "",
+        weight_column: str | None = None,
     ):
         self.features = features
         self.zero_threshold = zero_threshold
         self.n_quantiles = n_quantiles
         self.prefix = prefix
+        self.weight_column = weight_column
         self.features_out = [self.prefix + f for f in self.features]
 
         self._zero_proportion: dict[str, float] = {}
@@ -452,21 +457,82 @@ class QuantilePerformanceScaler(BaseEstimator, TransformerMixin):
 
     @nw.narwhalify
     def fit(self, df: IntoFrameT, y=None):
+        # Get weights if specified
+        weights = None
+        if self.weight_column is not None:
+            weights = df[self.weight_column].to_numpy()
+
         for feature in self.features:
             values = df[feature].to_numpy()
-            values = values[np.isfinite(values)]
 
-            is_zero = np.abs(values) < self.zero_threshold
-            self._zero_proportion[feature] = np.mean(is_zero)
+            # Create finite mask
+            finite_mask = np.isfinite(values)
+            if weights is not None:
+                # Also require finite, positive weights
+                weight_valid = np.isfinite(weights) & (weights > 0)
+                finite_mask = finite_mask & weight_valid
+
+            values_finite = values[finite_mask]
+
+            if weights is not None:
+                weights_finite = weights[finite_mask]
+            else:
+                weights_finite = None
+
+            is_zero = np.abs(values_finite) < self.zero_threshold
+
+            if weights_finite is not None:
+                # Weighted zero proportion: sum(weights where zero) / sum(weights)
+                total_weight = np.sum(weights_finite)
+                if total_weight > 0:
+                    self._zero_proportion[feature] = np.sum(weights_finite[is_zero]) / total_weight
+                else:
+                    self._zero_proportion[feature] = np.mean(is_zero)
+            else:
+                self._zero_proportion[feature] = np.mean(is_zero)
+
+            nonzero_mask = ~is_zero
+            nonzero_values = values_finite[nonzero_mask]
 
-            nonzero_values = values[~is_zero]
             if len(nonzero_values) > 0:
-                percentiles = np.linspace(0, 100, self.n_quantiles + 1)
-                self._nonzero_quantiles[feature] = np.percentile(nonzero_values, percentiles)
+                if weights_finite is not None:
+                    # Weighted quantiles using interpolation on weighted CDF
+                    nonzero_weights = weights_finite[nonzero_mask]
+                    self._nonzero_quantiles[feature] = self._compute_weighted_quantiles(
+                        nonzero_values, nonzero_weights
+                    )
+                else:
+                    percentiles = np.linspace(0, 100, self.n_quantiles + 1)
+                    self._nonzero_quantiles[feature] = np.percentile(nonzero_values, percentiles)
             else:
                 self._nonzero_quantiles[feature] = None
         return self
 
+    def _compute_weighted_quantiles(
+        self, values: np.ndarray, weights: np.ndarray
+    ) -> np.ndarray:
+        """Compute weighted quantiles using weighted CDF interpolation."""
+        # Sort by value
+        order = np.argsort(values)
+        sorted_values = values[order]
+        sorted_weights = weights[order]
+
+        # Compute weighted CDF
+        cumulative_weights = np.cumsum(sorted_weights)
+        total_weight = cumulative_weights[-1]
+
+        # Normalize CDF to [0, 1]
+        cdf = cumulative_weights / total_weight
+
+        # Sample quantiles at evenly spaced CDF positions
+        target_cdf = np.linspace(0, 1, self.n_quantiles + 1)
+
+        # Interpolate to get quantile values
+        # Use np.interp which handles edge cases gracefully
+        quantiles = np.interp(target_cdf, cdf, sorted_values)
+
+        return quantiles
+
     @nw.narwhalify
     def transform(self, df: IntoFrameT) -> IntoFrameT:
         for feature in self.features:

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

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

@@ -47,8 +47,8 @@ spforge/hyperparameter_tuning/__init__.py,sha256=Vcl8rVlJ7M708iPgqe4XxpZWgJKGux0
 spforge/hyperparameter_tuning/_default_search_spaces.py,sha256=SjwXLpvYIu_JY8uPRHeL5Kgp1aa0slWDz8qsKDaohWQ,8020
 spforge/hyperparameter_tuning/_tuner.py,sha256=M79q3saM6r0UZJsRUUgfdDr-3Qii-F2-wuSAZLFtZDo,19246
 spforge/performance_transformers/__init__.py,sha256=J-5olqi1M_BUj3sN1NqAz9s28XAbuKK9M9xHq7IGlQU,482
-spforge/performance_transformers/_performance_manager.py,sha256=_qXqj8aaVJyTuUXrZxbOSANwL5iO3Rd1yz9WBwYBTMA,12025
-spforge/performance_transformers/_performances_transformers.py,sha256=ZjkFDXoEe5fURpN-dNkrgFXpHEg4aFCWdBDnPyLtgkM,18368
+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/_player_rating.py,sha256=AIpDEl6cZaC3urcY-jFFgUWd4WZ71A33c5mOPfkXdMs,68178
@@ -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.37.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.38.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=Ja2TWq1vGoAqBSSeAWZ26drwEnsF6TmMmpQ0nsMRU_4,19163
-tests/performance_transformers/test_performances_transformers.py,sha256=HnW7GKQ6B0ova6Zy0lKbEpA6peZGFE4oi9Th6r7RnG0,18949
+tests/performance_transformers/test_performance_manager.py,sha256=tHyyyjAotJLtrViWx3j0DaNDqp3nowooMu5Wop7DjBE,24766
+tests/performance_transformers/test_performances_transformers.py,sha256=QyLNzis7yOBsjjclhuYrbZFaSmlTcSAbGVzNvK1B-SU,27817
 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.37.dist-info/METADATA,sha256=fLFkSzIsDRPKRpyJ-H126XcKG_NAUyXmJNGDNrogq4s,20048
-spforge-0.8.37.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.37.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.37.dist-info/RECORD,,
+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,,

tests/performance_transformers/test_performance_manager.py

@@ -436,6 +436,146 @@ class TestZeroInflationHandling:
         assert manager._using_quantile_scaler is True
 
 
+class TestWeightedQuantileScaling:
+    """Tests for weighted quantile scaling in PerformanceManager."""
+
+    @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})
+
+        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",
+        )
+
+        pm.fit(df)
+
+        # Should NOT have switched to quantile scaler
+        assert pm._using_quantile_scaler is False
+
+
 class TestAutoScalePerformanceBounds:
     """Tests for ensuring scaled performance stays within [0, 1] bounds."""
 

tests/performance_transformers/test_performances_transformers.py

@@ -551,3 +551,214 @@ class TestQuantilePerformanceScaler:
         # Non-zeros should all map to same value (since they're all equal)
         nonzero_values = transformed["x"].values[~is_zero.values]
         assert np.allclose(nonzero_values, nonzero_values[0])
+
+
+class TestWeightedQuantilePerformanceScaler:
+    """Tests for weighted 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  # 1 to ~100
+
+        # High-weight rows have lower zero probability
+        # This simulates: players with more minutes are more likely to have non-zero stats
+        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()
+
+        # Compute weighted mean
+        weighted_mean = np.average(weighted_scaled, weights=weights)
+
+        # 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}"
+        )
+
+    @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."""
+        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)
+
+        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})
+
+        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))