rename feature names to feature_names_out_

PaulWestenthanner · PaulWestenthanner · commit 0aefe554b243 · 2022-11-20T20:50:03.000+01:00
diff --git a/category_encoders/backward_difference.py b/category_encoders/backward_difference.py
@@ -38,7 +38,7 @@ class BackwardDifferenceEncoder(BaseContrastEncoder):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = BackwardDifferenceEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/basen.py b/category_encoders/basen.py
@@ -65,7 +65,7 @@ class BaseNEncoder(util.BaseEncoder, util.UnsupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = BaseNEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
@@ -180,7 +180,7 @@ def inverse_transform(self, X_in):
             raise ValueError('Must train encoder before it can be used to inverse_transform data')
 
         # unite the type into pandas dataframe (it makes the input size detection code easier...) and make deep copy
-        X = util.convert_input(X_in, columns=self.feature_names, deep=True)
+        X = util.convert_input(X_in, columns=self.feature_names_out_, deep=True)
 
         X = self.basen_to_integer(X, self.cols, self.base)
 
diff --git a/category_encoders/binary.py b/category_encoders/binary.py
@@ -36,7 +36,7 @@ class BinaryEncoder(BaseNEncoder):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = BinaryEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/cat_boost.py b/category_encoders/cat_boost.py
@@ -57,7 +57,7 @@ class CatBoostEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = CatBoostEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/count.py b/category_encoders/count.py
@@ -64,8 +64,8 @@ def __init__(self, verbose=0, cols=None, drop_invariant=False,
         combine_min_nan_groups: bool or dict of {column : bool, ...}.
             whether to combine the leftovers group with NaN group. Default True. Can
             also be forced to combine with 'force' meaning small groups are effectively
-            counted as NaNs. Force can only used when 'handle_missing' is 'value' or 'error'.
-            Note: Will not force if it creates an binary or invariant column.
+            counted as NaNs. Force can only be used when 'handle_missing' is 'value' or 'error'.
+            Note: Will not force if it creates a binary or invariant column.
 
 
         Example
@@ -76,7 +76,7 @@ def __init__(self, verbose=0, cols=None, drop_invariant=False,
 
         >>> bunch = load_boston()
         >>> y = bunch.target
-        >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+        >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
         >>> enc = CountEncoder(cols=['CHAS', 'RAD']).fit(X, y)
         >>> numeric_dataset = enc.transform(X)
 
diff --git a/category_encoders/glmm.py b/category_encoders/glmm.py
@@ -63,7 +63,7 @@ class GLMMEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target > 22.5
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = GLMMEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/gray.py b/category_encoders/gray.py
@@ -43,7 +43,7 @@ class GrayEncoder(BaseNEncoder):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = GrayEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/hashing.py b/category_encoders/hashing.py
@@ -63,7 +63,7 @@ class HashingEncoder(util.BaseEncoder, util.UnsupervisedTransformerMixin):
     >>> import pandas as pd
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> y = bunch.target
     >>> he = HashingEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> data = he.transform(X)
diff --git a/category_encoders/helmert.py b/category_encoders/helmert.py
@@ -39,7 +39,7 @@ class HelmertEncoder(BaseContrastEncoder):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = HelmertEncoder(cols=['CHAS', 'RAD'], handle_unknown='value', handle_missing='value').fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/james_stein.py b/category_encoders/james_stein.py
@@ -92,7 +92,7 @@ class JamesSteinEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = JamesSteinEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/leave_one_out.py b/category_encoders/leave_one_out.py
@@ -43,7 +43,7 @@ class LeaveOneOutEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = LeaveOneOutEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/m_estimate.py b/category_encoders/m_estimate.py
@@ -47,7 +47,7 @@ class MEstimateEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target > 22.5
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = MEstimateEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/one_hot.py b/category_encoders/one_hot.py
@@ -48,7 +48,7 @@ class OneHotEncoder(util.BaseEncoder, util.UnsupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = OneHotEncoder(cols=['CHAS', 'RAD'], handle_unknown='indicator').fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
@@ -217,7 +217,7 @@ def inverse_transform(self, X_in):
             raise ValueError('Must train encoder before it can be used to inverse_transform data')
 
         # first check the type and make deep copy
-        X = util.convert_input(X_in, columns=self.feature_names, deep=True)
+        X = util.convert_input(X_in, columns=self.feature_names_out_, deep=True)
 
         X = self.reverse_dummies(X, self.mapping)
 
diff --git a/category_encoders/ordinal.py b/category_encoders/ordinal.py
@@ -48,7 +48,7 @@ class OrdinalEncoder(util.BaseEncoder, util.UnsupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = OrdinalEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/polynomial.py b/category_encoders/polynomial.py
@@ -38,7 +38,7 @@ class PolynomialEncoder(BaseContrastEncoder):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = PolynomialEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/quantile_encoder.py b/category_encoders/quantile_encoder.py
@@ -9,6 +9,7 @@
 import numpy as np
 import pandas as pd
 from sklearn.base import BaseEstimator
+from sklearn.exceptions import NotFittedError
 
 import category_encoders.utils as util
 from category_encoders.ordinal import OrdinalEncoder
@@ -49,7 +50,7 @@ class QuantileEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = QuantileEncoder(cols=['CHAS', 'RAD'], quantile=0.5, m=1.0).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
@@ -198,7 +199,7 @@ class SummaryEncoder(BaseEstimator, util.TransformerWithTargetMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = SummaryEncoder(cols=["CHAS", "RAD"], quantiles=[0.25, 0.5, 0.75]).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
@@ -261,7 +262,7 @@ def __init__(
         self.mapping = None
         self.handle_unknown = handle_unknown
         self.handle_missing = handle_missing
-        self.feature_names = None
+        self.feature_names_out_ = None
         self.quantiles = quantiles
         self.m = m
         self.encoder_list = None
@@ -311,7 +312,7 @@ def fit(self, X, y):
             enc.fit(X.copy(), y)
             encoder_list.append(enc)
             self.drop_cols += enc.invariant_cols
-        self.feature_names = reduce(
+        self.feature_names_out_ = reduce(
             operator.add,
             [
                 [self._get_col_name(c, enc.quantile) for enc in encoder_list if c not in enc.invariant_cols]
@@ -361,10 +362,20 @@ def get_feature_names_out(self):
             Note: potentially dropped features are not included!
         """
 
-        if not isinstance(self.feature_names, list):
-            raise ValueError("Must fit data first. Affected feature names are not known before.")
+        if not isinstance(self.feature_names_out_, list):
+            raise NotFittedError("Must fit data first. Affected feature names are not known before.")
         else:
-            return self.feature_names
+            return self.feature_names_out_
+
+    def get_feature_names_in(self) -> List[str]:
+        """
+        Returns the names of all input columns present when fitting.
+        These columns are necessary for the transform step.
+       """
+        if not isinstance(self.cols, list):
+            raise NotFittedError("Estimator has to be fitted to return feature names.")
+        else:
+            return self.cols
 
     @staticmethod
     def _get_col_name(col: str, quantile: float) -> str:
diff --git a/category_encoders/sum_coding.py b/category_encoders/sum_coding.py
@@ -38,7 +38,7 @@ class SumEncoder(BaseContrastEncoder):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = SumEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/target_encoder.py b/category_encoders/target_encoder.py
@@ -61,7 +61,7 @@ class TargetEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = TargetEncoder(cols=['CHAS', 'RAD'], min_samples_leaf=20, smoothing=10).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
@@ -255,7 +255,7 @@ def _transform(self, X, y=None):
     def target_encode(self, X_in):
         X = X_in.copy(deep=True)
 
-        # Was not mapping extra columns as self.cols did not include new column
+        # Was not mapping extra columns as self.featuer_names_in did not include new column
         for col in self.cols:
             X[col] = X[col].map(self.mapping[col])
 
diff --git a/category_encoders/utils.py b/category_encoders/utils.py
@@ -168,7 +168,7 @@ def get_generated_cols(X_original, X_transformed, to_transform):
         X_transformed: df
             the transformed (current) DataFrame.
         to_transform: [str]
-            a list of columns that were transformed (as in the original DataFrame), commonly self.cols.
+            a list of columns that were transformed (as in the original DataFrame), commonly self.feature_names_in.
 
     Output:
         a list of columns that were transformed (as in the current DataFrame).
@@ -188,7 +188,7 @@ def get_generated_cols(X_original, X_transformed, to_transform):
 def flatten_reverse_dict(d):
     sep = "___"
     [flat_dict] = pd.json_normalize(d, sep=sep).to_dict(orient='records')
-    reversed_flat_dict = {v: tuple(k.split(sep)) for k,v in flat_dict.items()}
+    reversed_flat_dict = {v: tuple(k.split(sep)) for k, v in flat_dict.items()}
     return reversed_flat_dict
 
 
@@ -224,7 +224,7 @@ class BaseEncoder(BaseEstimator):
     verbose: int
     drop_invariant: bool
     invariant_cols: List[str] = []
-    feature_names: Union[None,  List[str]] = None
+    feature_names_out_: Union[None, List[str]] = None
     return_df: bool
     supervised: bool
     encoding_relation: EncodingRelation
@@ -264,11 +264,11 @@ def __init__(self, verbose=0, cols=None, drop_invariant=False, return_df=True,
         self.invariant_cols = []
         self.verbose = verbose
         self.use_default_cols = cols is None  # if True, even a repeated call of fit() will select string columns from X
-        self.cols = cols
+        self.cols = cols  # This cannot be called `feature_names_in_` since it is a parameter. This does not feel right
+        self.feature_names_out_ = None
         self.mapping = None
         self.handle_unknown = handle_unknown
         self.handle_missing = handle_missing
-        self.feature_names = None
         self._dim = None
 
     def fit(self, X, y=None, **kwargs):
@@ -294,7 +294,7 @@ def fit(self, X, y=None, **kwargs):
         X, y = convert_inputs(X, y)
 
         self._dim = X.shape[1]
-        self._get_fit_columns(X)
+        self._determine_fit_columns(X)
 
         if not set(self.cols).issubset(X.columns):
             raise ValueError('X does not contain the columns listed in cols')
@@ -307,13 +307,13 @@ def fit(self, X, y=None, **kwargs):
 
         # for finding invariant columns transform without y (as is done on the test set)
         X_transformed = self.transform(X, override_return_df=True)
-        self.feature_names = X_transformed.columns.tolist()
+        self.feature_names_out_ = X_transformed.columns.tolist()
 
         # drop all output columns with 0 variance.
         if self.drop_invariant:
             generated_cols = get_generated_cols(X, X_transformed, self.cols)
             self.invariant_cols = [x for x in generated_cols if X_transformed[x].var() <= self.INVARIANCE_THRESHOLD]
-            self.feature_names = [x for x in self.feature_names if x not in self.invariant_cols]
+            self.feature_names_out_ = [x for x in self.feature_names_out_ if x not in self.invariant_cols]
 
         return self
 
@@ -342,7 +342,7 @@ def _drop_invariants(self, X: pd.DataFrame, override_return_df: bool) -> Union[n
         else:
             return X.values
 
-    def _get_fit_columns(self, X: pd.DataFrame) -> None:
+    def _determine_fit_columns(self, X: pd.DataFrame) -> None:
         """ Determine columns used by encoder.
 
         Note that the implementation also deals with re-fitting the same encoder object with different columns.
@@ -372,10 +372,20 @@ def get_feature_names_out(self) -> List[str]:
             Note: potentially dropped features (because the feature is constant/invariant) are not included!
 
         """
-        if not isinstance(self.feature_names, list):
+        if not isinstance(self.feature_names_out_, list):
             raise NotFittedError("Estimator has to be fitted to return feature names.")
         else:
-            return self.feature_names
+            return self.feature_names_out_
+
+    def get_feature_names_in(self) -> List[str]:
+        """
+        Returns the names of all input columns present when fitting.
+        These columns are necessary for the transform step.
+       """
+        if not isinstance(self.cols, list):
+            raise NotFittedError("Estimator has to be fitted to return feature names.")
+        else:
+            return self.cols
 
     @abstractmethod
     def _fit(self, X: pd.DataFrame, y: Optional[pd.Series], **kwargs):
diff --git a/category_encoders/woe.py b/category_encoders/woe.py
@@ -42,7 +42,7 @@ class WOEEncoder(util.BaseEncoder, util.SupervisedTransformerMixin):
     >>> from sklearn.datasets import load_boston
     >>> bunch = load_boston()
     >>> y = bunch.target > 22.5
-    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names)
+    >>> X = pd.DataFrame(bunch.data, columns=bunch.feature_names_out_)
     >>> enc = WOEEncoder(cols=['CHAS', 'RAD']).fit(X, y)
     >>> numeric_dataset = enc.transform(X)
     >>> print(numeric_dataset.info())
diff --git a/category_encoders/wrapper.py b/category_encoders/wrapper.py
