featcopilot 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

featcopilot/selection/statistical.py

@@ -6,6 +6,9 @@ import numpy as np
 import pandas as pd
 
 from featcopilot.core.base import BaseSelector
+from featcopilot.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class StatisticalSelector(BaseSelector):
@@ -95,67 +98,137 @@ class StatisticalSelector(BaseSelector):
     def _compute_mutual_info(self, X: pd.DataFrame, y: np.ndarray) -> np.ndarray:
         """Compute mutual information scores."""
         from sklearn.feature_selection import mutual_info_classif, mutual_info_regression
+        from sklearn.preprocessing import LabelEncoder
 
-        # Determine if classification or regression
-        unique_y = len(np.unique(y))
-        is_classification = unique_y < 20 and y.dtype in [np.int32, np.int64, "object"]
-
-        X_array = X.fillna(0).values
+        # Encode string labels if needed
+        y_encoded = y
+        if y.dtype == object or y.dtype.kind in ("U", "S"):
+            le = LabelEncoder()
+            y_encoded = le.fit_transform(y)
 
-        if is_classification:
-            scores = mutual_info_classif(X_array, y, random_state=42)
-        else:
-            scores = mutual_info_regression(X_array, y, random_state=42)
+        # Determine if classification or regression
+        # Check if target is categorical (object type) or has discrete integer values
+        unique_y = len(np.unique(y_encoded))
+        is_classification = (
+            y.dtype == object
+            or y.dtype.kind in ("U", "S")
+            or (np.issubdtype(y_encoded.dtype, np.integer) and unique_y <= len(y_encoded) * 0.1)
+        )
+
+        # Filter to numeric columns only
+        numeric_cols = X.select_dtypes(include=[np.number]).columns.tolist()
+        scores = np.zeros(len(X.columns))
+
+        if numeric_cols:
+            X_numeric = X[numeric_cols].fillna(0).values
+            numeric_indices = [X.columns.get_loc(c) for c in numeric_cols]
+
+            if is_classification:
+                numeric_scores = mutual_info_classif(X_numeric, y_encoded, random_state=42)
+            else:
+                numeric_scores = mutual_info_regression(X_numeric, y_encoded, random_state=42)
+
+            for i, idx in enumerate(numeric_indices):
+                scores[idx] = numeric_scores[i]
 
         return scores
 
     def _compute_f_test(self, X: pd.DataFrame, y: np.ndarray) -> np.ndarray:
         """Compute F-test scores."""
         from sklearn.feature_selection import f_classif, f_regression
+        from sklearn.preprocessing import LabelEncoder
 
-        unique_y = len(np.unique(y))
-        is_classification = unique_y < 20
+        # Encode string labels if needed
+        y_encoded = y
+        if y.dtype == object or y.dtype.kind in ("U", "S"):
+            le = LabelEncoder()
+            y_encoded = le.fit_transform(y)
 
-        X_array = X.fillna(0).values
+        # Determine if classification or regression
+        unique_y = len(np.unique(y_encoded))
+        is_classification = (
+            y.dtype == object
+            or y.dtype.kind in ("U", "S")
+            or (np.issubdtype(y_encoded.dtype, np.integer) and unique_y <= len(y_encoded) * 0.1)
+        )
 
-        if is_classification:
-            scores, _ = f_classif(X_array, y)
-        else:
-            scores, _ = f_regression(X_array, y)
+        # Filter to numeric columns only
+        numeric_cols = X.select_dtypes(include=[np.number]).columns.tolist()
+        scores = np.zeros(len(X.columns))
+
+        if numeric_cols:
+            X_numeric = X[numeric_cols].fillna(0).values
+            numeric_indices = [X.columns.get_loc(c) for c in numeric_cols]
+
+            if is_classification:
+                numeric_scores, _ = f_classif(X_numeric, y_encoded)
+            else:
+                numeric_scores, _ = f_regression(X_numeric, y_encoded)
+
+            # Handle NaN scores
+            numeric_scores = np.nan_to_num(numeric_scores, 0)
+
+            for i, idx in enumerate(numeric_indices):
+                scores[idx] = numeric_scores[i]
 
-        # Handle NaN scores
-        scores = np.nan_to_num(scores, 0)
         return scores
 
     def _compute_chi2(self, X: pd.DataFrame, y: np.ndarray) -> np.ndarray:
         """Compute chi-square scores (for non-negative features)."""
         from sklearn.feature_selection import chi2
+        from sklearn.preprocessing import LabelEncoder
 
-        X_array = X.fillna(0).values
+        # Encode string labels if needed
+        y_encoded = y
+        if y.dtype == object or y.dtype.kind in ("U", "S"):
+            le = LabelEncoder()
+            y_encoded = le.fit_transform(y)
 
-        # Chi2 requires non-negative values
-        X_positive = X_array - X_array.min(axis=0) + 1e-8
+        # Filter to numeric columns only
+        numeric_cols = X.select_dtypes(include=[np.number]).columns.tolist()
+        scores = np.zeros(len(X.columns))
 
-        try:
-            scores, _ = chi2(X_positive, y)
-            scores = np.nan_to_num(scores, 0)
-        except Exception:
-            # Fallback to mutual information
-            scores = self._compute_mutual_info(X, y)
+        if numeric_cols:
+            X_numeric = X[numeric_cols].fillna(0).values
+            numeric_indices = [X.columns.get_loc(c) for c in numeric_cols]
+
+            # Chi2 requires non-negative values
+            X_positive = X_numeric - X_numeric.min(axis=0) + 1e-8
+
+            try:
+                numeric_scores, _ = chi2(X_positive, y_encoded)
+                numeric_scores = np.nan_to_num(numeric_scores, 0)
+            except Exception:
+                # Fallback to mutual information
+                return self._compute_mutual_info(X, y)
+
+            for i, idx in enumerate(numeric_indices):
+                scores[idx] = numeric_scores[i]
 
         return scores
 
     def _compute_correlation(self, X: pd.DataFrame, y: np.ndarray) -> np.ndarray:
         """Compute absolute correlation with target."""
-        scores = []
-        for col in X.columns:
+        from sklearn.preprocessing import LabelEncoder
+
+        # Encode string labels if needed
+        y_encoded = y
+        if y.dtype == object or y.dtype.kind in ("U", "S"):
+            le = LabelEncoder()
+            y_encoded = le.fit_transform(y).astype(float)
+
+        numeric_cols = X.select_dtypes(include=[np.number]).columns.tolist()
+        scores = np.zeros(len(X.columns))
+
+        for col in numeric_cols:
             try:
-                corr = np.abs(np.corrcoef(X[col].fillna(0).values, y)[0, 1])
-                scores.append(corr if not np.isnan(corr) else 0)
+                idx = X.columns.get_loc(col)
+                corr = np.abs(np.corrcoef(X[col].fillna(0).values, y_encoded)[0, 1])
+                scores[idx] = corr if not np.isnan(corr) else 0
             except Exception:
-                scores.append(0)
+                pass
 
-        return np.array(scores)
+        return scores
 
     def _select_features(self) -> None:
         """Select features based on scores."""
@@ -173,7 +246,7 @@ class StatisticalSelector(BaseSelector):
         self._selected_features = [name for name, _ in sorted_features]
 
         if self.verbose:
-            print(f"StatisticalSelector: Selected {len(self._selected_features)} features")
+            logger.info(f"StatisticalSelector: Selected {len(self._selected_features)} features")
 
     def transform(self, X: Union[pd.DataFrame, np.ndarray], **kwargs) -> pd.DataFrame:
         """

featcopilot/selection/unified.py

@@ -9,6 +9,9 @@ from featcopilot.core.base import BaseSelector
 from featcopilot.selection.importance import ImportanceSelector
 from featcopilot.selection.redundancy import RedundancyEliminator
 from featcopilot.selection.statistical import StatisticalSelector
+from featcopilot.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class FeatureSelector(BaseSelector):
@@ -43,6 +46,7 @@ class FeatureSelector(BaseSelector):
         max_features: Optional[int] = None,
         correlation_threshold: float = 0.95,
         combination: str = "union",
+        original_features: Optional[set[str]] = None,
         verbose: bool = False,
         **kwargs,
     ):
@@ -51,6 +55,7 @@ class FeatureSelector(BaseSelector):
         self.max_features = max_features
         self.correlation_threshold = correlation_threshold
         self.combination = combination  # 'union' or 'intersection'
+        self.original_features = original_features or set()
         self.verbose = verbose
         self._selectors: dict[str, BaseSelector] = {}
         self._method_scores: dict[str, dict[str, float]] = {}
@@ -73,6 +78,10 @@ class FeatureSelector(BaseSelector):
         X = self._validate_input(X)
         y = np.array(y)
 
+        # Identify categorical/text columns (can't be scored by numeric methods)
+        categorical_cols = X.select_dtypes(include=["object", "category"]).columns.tolist()
+        numeric_cols = X.select_dtypes(include=[np.number]).columns.tolist()
+
         # Initialize and fit each selector
         for method in self.methods:
             selector = self._create_selector(method)
@@ -83,11 +92,27 @@ class FeatureSelector(BaseSelector):
         # Combine scores from all methods
         self._combine_scores(X.columns.tolist())
 
+        # Give categorical columns a minimum score so they're not filtered out
+        # Original categorical columns are important for models that can handle them
+        if categorical_cols:
+            # Get the median score of numeric features to use as baseline for categorical
+            numeric_scores = [v for k, v in self._feature_scores.items() if k in numeric_cols and v > 0]
+            if numeric_scores:
+                baseline_score = np.median(numeric_scores)
+            else:
+                baseline_score = 0.5  # Default if no numeric scores
+
+            for col in categorical_cols:
+                if col in self.original_features:
+                    # Original categorical columns get a baseline score
+                    self._feature_scores[col] = max(self._feature_scores.get(col, 0), baseline_score)
+
         # Apply redundancy elimination
         if self.correlation_threshold < 1.0:
             eliminator = RedundancyEliminator(
                 correlation_threshold=self.correlation_threshold,
                 importance_scores=self._feature_scores,
+                original_features=self.original_features,
                 verbose=self.verbose,
             )
             eliminator.fit(X)
@@ -146,13 +171,42 @@ class FeatureSelector(BaseSelector):
         """Make final feature selection."""
         sorted_features = sorted(self._feature_scores.items(), key=lambda x: x[1], reverse=True)
 
+        # Always include original features first
+        original_selected = []
+        derived_selected = []
+
+        for name, score in sorted_features:
+            if name in self.original_features:
+                original_selected.append(name)
+            else:
+                # Only include derived features with meaningful importance (> 1% of max)
+                max_score = max(self._feature_scores.values()) if self._feature_scores else 1.0
+                importance_threshold = max_score * 0.01  # 1% threshold
+                if score >= importance_threshold:
+                    derived_selected.append(name)
+                elif self.verbose:
+                    logger.debug(f"Excluding low-importance feature {name} (score={score:.4f})")
+
+        # Apply max_features limit only to derived features
         if self.max_features is not None:
-            sorted_features = sorted_features[: self.max_features]
+            # Reserve slots for original features, then fill with top derived
+            n_derived = max(0, self.max_features - len(original_selected))
+            derived_selected = derived_selected[:n_derived]
 
-        self._selected_features = [name for name, _ in sorted_features]
+        self._selected_features = original_selected + derived_selected
+
+        # Ensure we never have fewer features than original
+        if len(self._selected_features) < len(self.original_features):
+            # This should not happen, but add all original features as safety
+            for f in self.original_features:
+                if f not in self._selected_features:
+                    self._selected_features.append(f)
 
         if self.verbose:
-            print(f"FeatureSelector: Selected {len(self._selected_features)} features")
+            logger.info(
+                f"FeatureSelector: Selected {len(self._selected_features)} features "
+                f"({len(original_selected)} original + {len(derived_selected)} derived)"
+            )
 
     def transform(self, X: Union[pd.DataFrame, np.ndarray], **kwargs) -> pd.DataFrame:
         """Select features from data."""

featcopilot/stores/__init__.py

@@ -0,0 +1,17 @@
+"""Feature store integrations for FeatCopilot.
+
+Provides interfaces to save and retrieve engineered features
+from popular feature stores like Feast, enabling feature reuse
+and serving in production ML systems.
+"""
+
+from featcopilot.stores.base import BaseFeatureStore, FeatureStoreConfig
+from featcopilot.stores.feast_store import FeastFeatureStore
+from featcopilot.stores.rule_store import TransformRuleStore
+
+__all__ = [
+    "BaseFeatureStore",
+    "FeatureStoreConfig",
+    "FeastFeatureStore",
+    "TransformRuleStore",
+]

featcopilot/stores/base.py

@@ -0,0 +1,166 @@
+"""Base classes for feature store integrations."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+import pandas as pd
+from pydantic import BaseModel, Field
+
+from featcopilot.core.feature import FeatureSet
+
+
+class FeatureStoreConfig(BaseModel):
+    """Base configuration for feature stores."""
+
+    name: str = Field(description="Feature store name")
+    entity_columns: list[str] = Field(default_factory=list, description="Entity/key columns")
+    timestamp_column: Optional[str] = Field(default=None, description="Event timestamp column")
+    feature_prefix: str = Field(default="", description="Prefix for feature names")
+    tags: dict[str, str] = Field(default_factory=dict, description="Tags/labels for features")
+
+
+class BaseFeatureStore(ABC):
+    """
+    Abstract base class for feature store integrations.
+
+    Provides a unified interface for saving and retrieving
+    engineered features from various feature stores.
+
+    Parameters
+    ----------
+    config : FeatureStoreConfig
+        Configuration for the feature store
+
+    Examples
+    --------
+    >>> store = ConcreteFeatureStore(config)
+    >>> store.save_features(X_transformed, feature_set, feature_view_name='my_features')
+    >>> features = store.get_features(entity_df, feature_names=['feat1', 'feat2'])
+    """
+
+    def __init__(self, config: FeatureStoreConfig):
+        self.config = config
+        self._is_initialized = False
+
+    @abstractmethod
+    def initialize(self) -> None:
+        """
+        Initialize connection to the feature store.
+
+        This should be called before any other operations.
+        """
+        pass
+
+    @abstractmethod
+    def save_features(
+        self,
+        df: pd.DataFrame,
+        feature_set: Optional[FeatureSet] = None,
+        feature_view_name: str = "featcopilot_features",
+        description: Optional[str] = None,
+        **kwargs,
+    ) -> None:
+        """
+        Save features to the feature store.
+
+        Parameters
+        ----------
+        df : DataFrame
+            DataFrame containing features to save
+        feature_set : FeatureSet, optional
+            FeatCopilot FeatureSet with metadata
+        feature_view_name : str
+            Name for the feature view/table
+        description : str, optional
+            Description of the feature view
+        **kwargs
+            Additional store-specific options
+        """
+        pass
+
+    @abstractmethod
+    def get_features(
+        self,
+        entity_df: pd.DataFrame,
+        feature_names: list[str],
+        feature_view_name: str = "featcopilot_features",
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Retrieve features from the feature store.
+
+        Parameters
+        ----------
+        entity_df : DataFrame
+            DataFrame with entity keys and timestamps
+        feature_names : list
+            Names of features to retrieve
+        feature_view_name : str
+            Name of the feature view/table
+        **kwargs
+            Additional store-specific options
+
+        Returns
+        -------
+        DataFrame
+            DataFrame with requested features
+        """
+        pass
+
+    @abstractmethod
+    def list_feature_views(self) -> list[str]:
+        """
+        List all feature views in the store.
+
+        Returns
+        -------
+        list
+            Names of feature views
+        """
+        pass
+
+    @abstractmethod
+    def get_feature_view_schema(self, feature_view_name: str) -> dict[str, Any]:
+        """
+        Get schema/metadata for a feature view.
+
+        Parameters
+        ----------
+        feature_view_name : str
+            Name of the feature view
+
+        Returns
+        -------
+        dict
+            Schema information
+        """
+        pass
+
+    @abstractmethod
+    def delete_feature_view(self, feature_view_name: str) -> bool:
+        """
+        Delete a feature view.
+
+        Parameters
+        ----------
+        feature_view_name : str
+            Name of the feature view to delete
+
+        Returns
+        -------
+        bool
+            Whether deletion was successful
+        """
+        pass
+
+    def close(self) -> None:
+        """Close connection to the feature store."""
+        self._is_initialized = False
+
+    def __enter__(self):
+        self.initialize()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False