Skip to content

base

Base classes for feature engineering engines and selectors.

BaseEngine

Bases: ABC

Abstract base class for feature engineering engines.

All engines (tabular, timeseries, relational, llm) inherit from this class.

Source code in featcopilot/core/base.py 
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
class BaseEngine(ABC):
    """
    Abstract base class for feature engineering engines.

    All engines (tabular, timeseries, relational, llm) inherit from this class.
    """

    def __init__(self, config: Optional[EngineConfig] = None, **kwargs):
        self.config = config or EngineConfig(name=self.__class__.__name__, **kwargs)
        self._is_fitted = False
        self._feature_names: list[str] = []
        self._feature_metadata: dict[str, Any] = {}

    @property
    def is_fitted(self) -> bool:
        """Check if engine has been fitted."""
        return self._is_fitted

    @abstractmethod
    def fit(
        self,
        X: Union[pd.DataFrame, np.ndarray],
        y: Optional[Union[pd.Series, np.ndarray]] = None,
        **kwargs,
    ) -> "BaseEngine":
        """
        Fit the engine to the data.

        Parameters
        ----------
        X : DataFrame or ndarray
            Input features
        y : Series or ndarray, optional
            Target variable
        **kwargs : dict
            Additional parameters

        Returns
        -------
        self : BaseEngine
            Fitted engine
        """
        pass

    @abstractmethod
    def transform(self, X: Union[pd.DataFrame, np.ndarray], **kwargs) -> pd.DataFrame:
        """
        Transform data to generate new features.

        Parameters
        ----------
        X : DataFrame or ndarray
            Input features
        **kwargs : dict
            Additional parameters

        Returns
        -------
        X_transformed : DataFrame
            Transformed features
        """
        pass

    def fit_transform(
        self,
        X: Union[pd.DataFrame, np.ndarray],
        y: Optional[Union[pd.Series, np.ndarray]] = None,
        **kwargs,
    ) -> pd.DataFrame:
        """Fit and transform in one step."""
        return self.fit(X, y, **kwargs).transform(X, **kwargs)

    def get_feature_names(self) -> list[str]:
        """Get names of generated features."""
        return self._feature_names.copy()

    def get_feature_metadata(self) -> dict[str, Any]:
        """Get metadata for generated features."""
        return self._feature_metadata.copy()

    def _validate_input(self, X: Union[pd.DataFrame, np.ndarray]) -> pd.DataFrame:
        """Convert input to DataFrame and validate."""
        if isinstance(X, np.ndarray):
            X = pd.DataFrame(X, columns=[f"feature_{i}" for i in range(X.shape[1])])
        elif not isinstance(X, pd.DataFrame):
            raise TypeError(f"Expected DataFrame or ndarray, got {type(X)}")
        return X

is_fitted property

Check if engine has been fitted.

fit(X, y=None, **kwargs) abstractmethod

Fit the engine to the data.

Parameters:

Name Type Description Default
X DataFrame or ndarray

Input features

 required
y Series or ndarray

Target variable

 None
**kwargs dict

Additional parameters

 {}

Returns:

Name Type Description
self BaseEngine

Fitted engine
Source code in featcopilot/core/base.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@abstractmethod
def fit(
    self,
    X: Union[pd.DataFrame, np.ndarray],
    y: Optional[Union[pd.Series, np.ndarray]] = None,
    **kwargs,
) -> "BaseEngine":
    """
    Fit the engine to the data.

    Parameters
    ----------
    X : DataFrame or ndarray
        Input features
    y : Series or ndarray, optional
        Target variable
    **kwargs : dict
        Additional parameters

    Returns
    -------
    self : BaseEngine
        Fitted engine
    """
    pass

fit_transform(X, y=None, **kwargs)

Fit and transform in one step.

Source code in featcopilot/core/base.py 
83
84
85
86
87
88
89
90
def fit_transform(
    self,
    X: Union[pd.DataFrame, np.ndarray],
    y: Optional[Union[pd.Series, np.ndarray]] = None,
    **kwargs,
) -> pd.DataFrame:
    """Fit and transform in one step."""
    return self.fit(X, y, **kwargs).transform(X, **kwargs)

get_feature_metadata()

Get metadata for generated features.

Source code in featcopilot/core/base.py 
96
97
98
def get_feature_metadata(self) -> dict[str, Any]:
    """Get metadata for generated features."""
    return self._feature_metadata.copy()

get_feature_names()

Get names of generated features.

Source code in featcopilot/core/base.py 
92
93
94
def get_feature_names(self) -> list[str]:
    """Get names of generated features."""
    return self._feature_names.copy()

transform(X, **kwargs) abstractmethod

Transform data to generate new features.

Parameters:

Name Type Description Default
X DataFrame or ndarray

Input features

 required
**kwargs dict

Additional parameters

 {}

Returns:

Name Type Description
X_transformed DataFrame

Transformed features
Source code in featcopilot/core/base.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
@abstractmethod
def transform(self, X: Union[pd.DataFrame, np.ndarray], **kwargs) -> pd.DataFrame:
    """
    Transform data to generate new features.

    Parameters
    ----------
    X : DataFrame or ndarray
        Input features
    **kwargs : dict
        Additional parameters

    Returns
    -------
    X_transformed : DataFrame
        Transformed features
    """
    pass

BaseSelector

Bases: ABC

Abstract base class for feature selection.

Handles selection of most important/relevant features from generated set.

Source code in featcopilot/core/base.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
class BaseSelector(ABC):
    """
    Abstract base class for feature selection.

    Handles selection of most important/relevant features from generated set.
    """

    def __init__(self, config: Optional[SelectorConfig] = None, **kwargs):
        self.config = config or SelectorConfig(**kwargs)
        self._is_fitted = False
        self._selected_features: list[str] = []
        self._feature_scores: dict[str, float] = {}

    @property
    def is_fitted(self) -> bool:
        """Check if selector has been fitted."""
        return self._is_fitted

    @abstractmethod
    def fit(self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray], **kwargs) -> "BaseSelector":
        """
        Fit the selector to determine feature importance.

        Parameters
        ----------
        X : DataFrame or ndarray
            Input features
        y : Series or ndarray
            Target variable
        **kwargs : dict
            Additional parameters

        Returns
        -------
        self : BaseSelector
            Fitted selector
        """
        pass

    @abstractmethod
    def transform(self, X: Union[pd.DataFrame, np.ndarray], **kwargs) -> pd.DataFrame:
        """
        Transform data to keep only selected features.

        Parameters
        ----------
        X : DataFrame or ndarray
            Input features
        **kwargs : dict
            Additional parameters

        Returns
        -------
        X_selected : DataFrame
            Data with only selected features
        """
        pass

    def fit_transform(
        self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray], **kwargs
    ) -> pd.DataFrame:
        """Fit and transform in one step."""
        return self.fit(X, y, **kwargs).transform(X, **kwargs)

    def get_selected_features(self) -> list[str]:
        """Get names of selected features."""
        return self._selected_features.copy()

    def get_feature_scores(self) -> dict[str, float]:
        """Get importance scores for all features."""
        return self._feature_scores.copy()

    def _validate_input(self, X: Union[pd.DataFrame, np.ndarray]) -> pd.DataFrame:
        """Convert input to DataFrame and validate."""
        if isinstance(X, np.ndarray):
            X = pd.DataFrame(X, columns=[f"feature_{i}" for i in range(X.shape[1])])
        elif not isinstance(X, pd.DataFrame):
            raise TypeError(f"Expected DataFrame or ndarray, got {type(X)}")
        return X

is_fitted property

Check if selector has been fitted.

fit(X, y, **kwargs) abstractmethod

Fit the selector to determine feature importance.

Parameters:

Name Type Description Default
X DataFrame or ndarray

Input features

 required
y Series or ndarray

Target variable

 required
**kwargs dict

Additional parameters

 {}

Returns:

Name Type Description
self BaseSelector

Fitted selector
Source code in featcopilot/core/base.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
@abstractmethod
def fit(self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray], **kwargs) -> "BaseSelector":
    """
    Fit the selector to determine feature importance.

    Parameters
    ----------
    X : DataFrame or ndarray
        Input features
    y : Series or ndarray
        Target variable
    **kwargs : dict
        Additional parameters

    Returns
    -------
    self : BaseSelector
        Fitted selector
    """
    pass

fit_transform(X, y, **kwargs)

Fit and transform in one step.

Source code in featcopilot/core/base.py 
175
176
177
178
179
def fit_transform(
    self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray], **kwargs
) -> pd.DataFrame:
    """Fit and transform in one step."""
    return self.fit(X, y, **kwargs).transform(X, **kwargs)

get_feature_scores()

Get importance scores for all features.

Source code in featcopilot/core/base.py 
185
186
187
def get_feature_scores(self) -> dict[str, float]:
    """Get importance scores for all features."""
    return self._feature_scores.copy()

get_selected_features()

Get names of selected features.

Source code in featcopilot/core/base.py 
181
182
183
def get_selected_features(self) -> list[str]:
    """Get names of selected features."""
    return self._selected_features.copy()

transform(X, **kwargs) abstractmethod

Transform data to keep only selected features.

Parameters:

Name Type Description Default
X DataFrame or ndarray

Input features

 required
**kwargs dict

Additional parameters

 {}

Returns:

Name Type Description
X_selected DataFrame

Data with only selected features
Source code in featcopilot/core/base.py 
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
@abstractmethod
def transform(self, X: Union[pd.DataFrame, np.ndarray], **kwargs) -> pd.DataFrame:
    """
    Transform data to keep only selected features.

    Parameters
    ----------
    X : DataFrame or ndarray
        Input features
    **kwargs : dict
        Additional parameters

    Returns
    -------
    X_selected : DataFrame
        Data with only selected features
    """
    pass

EngineConfig

Bases: BaseModel

Configuration for feature engineering engines.

Source code in featcopilot/core/base.py 
11
12
13
14
15
16
17
class EngineConfig(BaseModel):
    """Configuration for feature engineering engines."""

    name: str = Field(description="Engine name")
    enabled: bool = Field(default=True, description="Whether engine is enabled")
    max_features: Optional[int] = Field(default=None, description="Max features to generate")
    verbose: bool = Field(default=False, description="Verbose output")

SelectorConfig

Bases: BaseModel

Configuration for feature selectors.

Source code in featcopilot/core/base.py 
109
110
111
112
113
114
class SelectorConfig(BaseModel):
    """Configuration for feature selectors."""

    max_features: Optional[int] = Field(default=None, description="Max features to select")
    min_importance: float = Field(default=0.0, description="Minimum importance threshold")
    correlation_threshold: float = Field(default=0.95, description="Threshold for correlation-based elimination")