spforge 0.8.13__tar.gz → 0.8.15__tar.gz

{spforge-0.8.13/spforge.egg-info → spforge-0.8.15}/PKG-INFO

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

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

@@ -264,6 +264,7 @@ class AutoPipeline(BaseEstimator):
         self.numeric_features = numeric_features
         self.remainder = remainder
         self._cat_feats = []
+        self._filter_feature_names: list[str] = []
 
         # Auto-compute context features
         self.context_feature_names = self._compute_context_features()
@@ -276,11 +277,12 @@ class AutoPipeline(BaseEstimator):
         self._resolved_categorical_handling: CategoricalHandling | None = None
 
     def _compute_context_features(self) -> list[str]:
-        """Auto-compute context features from estimator, granularity, and filters.
+        """Auto-compute context features from estimator and granularity.
 
         Note: Context from predictor_transformers is tracked separately in
         context_predictor_transformer_feature_names and is dropped before
-        the final estimator.
+        the final estimator. Filter columns are tracked separately and are
+        dropped before the final estimator.
         """
         from spforge.transformers._base import PredictorTransformer
 
@@ -325,8 +327,10 @@ class AutoPipeline(BaseEstimator):
         context.extend(self.granularity)
 
         # Add filter columns
+        self._filter_feature_names = []
         for f in self.filters:
-            context.append(f.column_name)
+            if f.column_name not in self._filter_feature_names:
+                self._filter_feature_names.append(f.column_name)
 
         # Dedupe while preserving order, excluding estimator_features
         seen = set()
@@ -540,8 +544,10 @@ class AutoPipeline(BaseEstimator):
             prev_transformer_feats_out.extend(feats_out)
 
         # Use FunctionTransformer with global function for serializability
+        drop_filter_cols = set(self._filter_feature_names)
+        drop_cols = drop_ctx_set | drop_filter_cols
         final = FunctionTransformer(
-            _drop_columns_transformer, validate=False, kw_args={"drop_cols": drop_ctx_set}
+            _drop_columns_transformer, validate=False, kw_args={"drop_cols": drop_cols}
         )
         steps.append(("final", final))
 
@@ -572,6 +578,7 @@ class AutoPipeline(BaseEstimator):
                 self.feature_names
                 + self.context_feature_names
                 + self.context_predictor_transformer_feature_names
+                + self._filter_feature_names
                 + self.granularity
             )
         )
@@ -660,6 +667,11 @@ class AutoPipeline(BaseEstimator):
             if ctx not in all_features:
                 all_features.append(ctx)
 
+        # Add filter columns (needed for fit-time filtering)
+        for col in self._filter_feature_names:
+            if col not in all_features:
+                all_features.append(col)
+
         return all_features
 
     def _get_estimator_feature_names(self) -> list[str]:
@@ -679,8 +691,28 @@ class AutoPipeline(BaseEstimator):
         context_set = set(self.context_feature_names)
         features = [f for f in features if f not in context_set]
 
+        # Remove filter columns (used only for fit-time filtering)
+        filter_set = set(self._filter_feature_names)
+        features = [f for f in features if f not in filter_set]
+
         return features
 
+    def _resolve_importance_feature_names(self, estimator, n_features: int) -> list[str]:
+        names = None
+        if hasattr(estimator, "feature_names_in_") and estimator.feature_names_in_ is not None:
+            names = list(estimator.feature_names_in_)
+        elif hasattr(estimator, "feature_name_") and estimator.feature_name_ is not None:
+            names = list(estimator.feature_name_)
+        elif hasattr(estimator, "feature_names_") and estimator.feature_names_ is not None:
+            names = list(estimator.feature_names_)
+        if names is None:
+            names = self._get_estimator_feature_names()
+        if len(names) != n_features:
+            raise ValueError(
+                f"Feature names length ({len(names)}) does not match importances length ({n_features})."
+            )
+        return names
+
     @property
     def feature_importances_(self) -> pd.DataFrame:
         """Get feature importances from the fitted estimator.
@@ -719,3 +751,33 @@ class AutoPipeline(BaseEstimator):
         df = pd.DataFrame({"feature": feature_names, "importance": importances})
         df = df.sort_values("importance", ascending=False, key=abs).reset_index(drop=True)
         return df
+
+    @property
+    def feature_importance_names(self) -> dict[str, float]:
+        """Map deepest estimator feature names to importances."""
+        if self.sklearn_pipeline is None:
+            raise RuntimeError("Pipeline not fitted. Call fit() first.")
+
+        est = self.sklearn_pipeline.named_steps["est"]
+        result = _get_importance_estimator(est)
+
+        if result is None:
+            raise RuntimeError(
+                "Estimator does not support feature importances. "
+                "Requires feature_importances_ or coef_ attribute."
+            )
+
+        inner_est, attr_name = result
+        raw = getattr(inner_est, attr_name)
+
+        if attr_name == "coef_":
+            if raw.ndim == 2:
+                importances = np.abs(raw).mean(axis=0)
+            else:
+                importances = np.abs(raw)
+        else:
+            importances = raw
+
+        importances = np.asarray(importances)
+        feature_names = self._resolve_importance_feature_names(inner_est, len(importances))
+        return dict(zip(feature_names, importances.tolist()))

{spforge-0.8.13 → spforge-0.8.15/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.13
+Version: 0.8.15
 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.13 → spforge-0.8.15}/tests/test_autopipeline.py

@@ -12,6 +12,7 @@ from sklearn.linear_model import LinearRegression, LogisticRegression
 
 from spforge import AutoPipeline
 from spforge.estimator import SkLearnEnhancerEstimator
+from spforge.scorer import Filter, Operator
 from spforge.transformers import EstimatorTransformer
 
 
@@ -231,6 +232,27 @@ def test_predict_proba(df_clf):
     assert np.allclose(proba.sum(axis=1), 1.0, atol=1e-6)
 
 
+def test_filter_columns_not_passed_to_estimator(frame):
+    df_pd = pd.DataFrame(
+        {"x": [1.0, 2.0, 3.0, 4.0], "keep": [1, 0, 1, 0], "y": [1.0, 2.0, 3.0, 4.0]}
+    )
+    df = df_pd if frame == "pd" else pl.from_pandas(df_pd)
+
+    model = AutoPipeline(
+        estimator=CaptureEstimator(),
+        estimator_features=["x"],
+        filters=[Filter(column_name="keep", value=1, operator=Operator.EQUALS)],
+    )
+
+    X = _select(df, ["x", "keep"])
+    y = _col(df, "y")
+    model.fit(X, y=y)
+
+    est = _inner_estimator(model)
+    assert "keep" in model.required_features
+    assert "keep" not in est.fit_columns
+
+
 def test_predict_proba_raises_if_not_supported(df_reg):
     model = AutoPipeline(
         estimator=LinearRegression(),
@@ -692,3 +714,34 @@ def test_feature_importances__onehot_features():
     assert len(importances) == 4
     assert "num1" in importances["feature"].tolist()
     assert any("cat1_" in f for f in importances["feature"].tolist())
+
+
+def test_feature_importance_names__granularity_uses_deep_feature_names():
+    from sklearn.ensemble import RandomForestRegressor
+
+    df = pd.DataFrame(
+        {
+            "gameid": ["g1", "g1", "g2", "g2"],
+            "num1": [1.0, 2.0, 3.0, 4.0],
+            "num2": [10.0, 20.0, 30.0, 40.0],
+        }
+    )
+    y = pd.Series([1.0, 2.0, 3.0, 4.0], name="y")
+
+    model = AutoPipeline(
+        estimator=RandomForestRegressor(n_estimators=5, random_state=42),
+        estimator_features=["gameid", "num1", "num2"],
+        predictor_transformers=[AddConstantPredictionTransformer(col_name="const_pred")],
+        granularity=["gameid"],
+        categorical_features=["gameid"],
+        categorical_handling="ordinal",
+        remainder="drop",
+    )
+    model.fit(df, y)
+
+    names = model.feature_importance_names
+
+    inner = _inner_estimator(model)
+    assert list(names.keys()) == list(inner.feature_names_in_)
+    assert "gameid" not in names
+    assert "const_pred" in names