def transform(self, X: pd.DataFrame) -> pd.DataFrame:
"""
Common input and transformer checks.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The data to transform.
Returns
-------
X_new: Pandas dataframe
The dataframe with the original variables plus the new variables.
"""
# Check method fit has been called
check_is_fitted(self)
# check that input is a dataframe
X = check_X(X)
# Check if input data contains same number of columns as dataframe used to fit.
_check_X_matches_training_df(X, self.n_features_in_)
# check if dataset contains na
if self.missing_values == "raise":
_check_contains_na(X, self.variables)
_check_contains_inf(X, self.variables)
# reorder variables to match train set
X = X[self.feature_names_in_]
return X
def transform(self, X):
"""
Groups rare labels under separate group 'Rare' or any other name provided
by the user.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The input samples.
Returns
-------
X_transformed : pandas dataframe of shape = [n_samples, n_features]
The dataframe where rare categories have been grouped.
"""
# Check method fit has been called
check_is_fitted(self)
# check that input is a dataframe
X = _is_dataframe(X)
# check if dataset contains na
_check_contains_na(X, self.variables)
# Check that the dataframe contains the same number of columns than the dataframe
# used to fit the imputer.
_check_input_matches_training_df(X, self.input_shape_[1])
for feature in self.variables:
X[feature] = np.where(X[feature].isin(self.encoder_dict_[feature]), X[feature], self.replace_with)
return X
def transform(self, X: pd.DataFrame):
"""
Return dataframe with selected features.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features].
The input dataframe from which feature values will be train.
Returns
-------
X_transformed: pandas dataframe
of shape = [n_samples, selected_features]
Pandas dataframe with the selected features.
"""
# check if fit is performed prior to transform
check_is_fitted(self)
# check if input is a dataframe
X = _is_dataframe(X)
# check if number of columns in test dataset matches to train dataset
_check_input_matches_training_df(X, self.input_shape_[1])
_check_contains_na(X, self.variables)
return X[self.selected_features_]
def fit(self, X: pd.DataFrame, y: pd.Series = None):
"""Learns and stores the names of the variables in the training dataset.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The input dataframe
y: None
y is not needed for this transformer. You can pass y or None.
Raises
------
TypeError
- If the input is not a Pandas DataFrame
Returns
-------
self
"""
X = _is_dataframe(X)
if self.missing_values == "raise":
# check if dataset contains na
_check_contains_na(X, X.columns)
# save input features
self.input_features_: List[Union[str, int]] = X.columns.tolist()
self.n_features_in_ = X.shape[1]
return self
def transform(self, X: pd.DataFrame) -> pd.DataFrame:
"""
Replaces the categorical variables by the binary variables.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The data to transform.
Returns
-------
X_new: pandas dataframe.
The transformed dataframe. The shape of the dataframe will be different from
the original as it includes the dummy variables in place of the of the
original categorical ones.
"""
X = self._check_transform_input_and_state(X)
# check if dataset contains na
_check_contains_na(X, self.variables_)
for feature in self.variables_:
for category in self.encoder_dict_[feature]:
X[str(feature) + "_" + str(category)] = np.where(
X[feature] == category, 1, 0
)
# drop the original non-encoded variables.
X.drop(labels=self.variables_, axis=1, inplace=True)
return X
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
Learn the encodings or levels to use for representing categorical variables.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training dataset. Can be the entire dataframe, not just the
variables to be transformed.
y: pandas Series, default = None
y is not needed in this encoder. You can pass y or None.
"""
X = check_X(X)
self._check_or_select_variables(X)
if self.missing_values == "raise":
_check_contains_na(X, self.variables_)
self._get_feature_names_in(X)
self.category_dict_ = dict()
for var in self.variables_:
self.category_dict_[var] = pd.Categorical(X[var]).categories
return self
def transform(self, X):
"""
Drop the correlated features from a dataframe.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features].
The input samples.
Returns
-------
X_transformed : pandas dataframe
shape = [n_samples, n_features - (correlated features)]
The transformed dataframe with the remaining subset of variables.
"""
# check if fit is performed prior to transform
check_is_fitted(self)
# check if input is a dataframe
X = _is_dataframe(X)
# check if number of columns in test dataset matches to train dataset
_check_input_matches_training_df(X, self.input_shape_[1])
if self.missing_values == "raise":
# check if dataset contains na
_check_contains_na(X, self.variables)
# returned non-correlated features
X = X.drop(columns=self.correlated_features_)
return X
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None) -> pd.DataFrame:
"""
Fits the transformation to the DataFrame.
Args:
X: Pandas DataFrame to fit the transformation
y: This parameter exists only for compatibility with
sklearn.pipeline.Pipeline.
Defaults to None. Alternatively takes Pandas Series.
Returns:
DataFrame with fitted transformation
"""
# check input dataframe
X = _is_dataframe(X)
# find or check for numerical variables
self.variables = _find_numerical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
return X
def transform(self, X):
"""
Returns the predictions of the decision tree based of the variable's original value.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The input samples.
Returns
-------
X_transformed : pandas dataframe of shape = [n_samples, n_features].
Dataframe with variables encoded with decision tree predictions.
"""
# Check method fit has been called
check_is_fitted(self)
# check that input is a dataframe
X = _is_dataframe(X)
# check if dataset contains na
_check_contains_na(X, self.variables)
# Check that the dataframe contains the same number of columns than the dataframe
# used to fit the imputer.
_check_input_matches_training_df(X, self.input_shape_[1])
X = self.encoder_.transform(X)
return X
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
Common set-up of creation transformers.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training input samples.
y: pandas Series, or np.array. Defaults to None.
It is not needed in this transformer. You can pass y or None.
"""
# check input dataframe
X = check_X(X)
# check variables are numerical
self.variables: List[Union[str,
int]] = _find_or_check_numerical_variables(
X, self.variables)
# check if dataset contains na
if self.missing_values == "raise":
_check_contains_na(X, self.variables)
_check_contains_inf(X, self.variables)
# save input features
self.feature_names_in_ = X.columns.tolist()
# save train set shape
self.n_features_in_ = X.shape[1]
return X
def transform(self, X: pd.DataFrame) -> pd.DataFrame:
"""
Group infrequent categories. Replace infrequent categories by the string 'Rare'
or any other name provided by the user.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The input samples.
Returns
-------
X: pandas dataframe of shape = [n_samples, n_features]
The dataframe where rare categories have been grouped.
"""
X = self._check_transform_input_and_state(X)
# check if dataset contains na
_check_contains_na(X, self.variables_)
for feature in self.variables_:
X[feature] = np.where(
X[feature].isin(self.encoder_dict_[feature]),
X[feature],
self.replace_with,
)
return X
def fit(self, X: pd.DataFrame, y: pd.Series = None):
"""
Find constant and quasi-constant features.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The input dataframe.
y : None
y is not needed for this transformer. You can pass y or None.
Returns
-------
self
"""
# check input dataframe
X = _is_dataframe(X)
# find all variables or check those entered are present in the dataframe
self.variables = _find_all_variables(X, self.variables)
if self.missing_values == "raise":
# check if dataset contains na
_check_contains_na(X, self.variables)
if self.missing_values == "include":
X[self.variables] = X[self.variables].fillna("missing_values")
# find constant features
if self.tol == 1:
self.features_to_drop_ = [
feature for feature in self.variables
if X[feature].nunique() == 1
]
# find constant and quasi-constant features
else:
self.features_to_drop_ = []
for feature in self.variables:
# find most frequent value / category in the variable
predominant = ((X[feature].value_counts() /
np.float(len(X))).sort_values(
ascending=False).values[0])
if predominant >= self.tol:
self.features_to_drop_.append(feature)
# check we are not dropping all the columns in the df
if len(self.features_to_drop_) == len(X.columns):
raise ValueError(
"The resulting dataframe will have no columns after dropping all "
"constant or quasi-constant features. Try changing the tol value."
)
self.input_shape_ = X.shape
return self
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
This transformer does not learn parameters.
Perform dataframe checks. Creates dictionary of operation to new feature
name pairs.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training input samples. Can be the entire dataframe, not just the
variables to transform.
y: pandas Series, or np.array. Defaults to None.
It is not needed in this transformer. You can pass y or None.
"""
# check input dataframe
X = check_X(X)
# check variables to combine are numerical
self.variables_to_combine = _find_or_check_numerical_variables(
X, self.variables_to_combine)
# check if dataset contains na
if self.missing_values == "raise":
_check_contains_na(X, self.variables_to_combine)
_check_contains_inf(X, self.variables_to_combine)
if self.math_operations is None:
self.math_operations_ = [
"sum", "prod", "mean", "std", "max", "min"
]
else:
self.math_operations_ = self.math_operations
# dictionary of new_variable_name to operation pairs
if self.new_variables_names:
self.combination_dict_ = dict(
zip(self.new_variables_names, self.math_operations_))
else:
if all(isinstance(var, str) for var in self.variables_to_combine):
vars_ls = self.variables_to_combine
else:
vars_ls = [str(var) for var in self.variables_to_combine]
self.combination_dict_ = {
f"{operation}({'-'.join(vars_ls)})": operation # type: ignore
for operation in self.math_operations_
}
# save input features
self.feature_names_in_ = X.columns.tolist()
# save train set shape
self.n_features_in_ = X.shape[1]
return self
def fit(self, X, y=None):
"""
Learns the frequent categories for each variable.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The training input samples.
Can be the entire dataframe, not just selected variables
y : None
y is not required. You can pass y or None.
Attributes
----------
encoder_dict_: dictionary
The dictionary containing the frequent categories (that will be kept)
for each variable. Categories not present in this list will be replaced
by 'Rare' or by the user defined value.
"""
# check input dataframe
X = _is_dataframe(X)
# find categorical variables or check that those entered by the user
# are of type object
self.variables = _find_categorical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
self.encoder_dict_ = {}
for var in self.variables:
if len(X[var].unique()) > self.n_categories:
# if the variable has more than the indicated number of categories
# the encoder will learn the most frequent categories
t = pd.Series(X[var].value_counts() / np.float(len(X)))
# non-rare labels:
self.encoder_dict_[var] = t[t >= self.tol].index
else:
# if the total number of categories is smaller than the indicated
# the encoder will consider all categories as frequent.
warnings.warn(
"The number of unique categories for variable {} is less than that indicated in "
"n_categories. Thus, all categories will be considered frequent"
.format(var))
self.encoder_dict_[var] = X[var].unique()
self.encoder_dict_ = _check_encoding_dictionary(self.encoder_dict_)
self.input_shape_ = X.shape
return self
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
This transformer does not learn any parameter.
Finds datetime variables or checks that the variables selected by the user
can be converted to datetime.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training input samples. Can be the entire dataframe, not just the
variables to transform.
y: pandas Series, default=None
It is not needed in this transformer. You can pass y or None.
"""
# check input dataframe
X = check_X(X)
# special case index
if self.variables == "index":
if not (
is_datetime(X.index)
or (
not is_numeric(X.index) and _is_categorical_and_is_datetime(X.index)
)
):
raise TypeError("The dataframe index is not datetime.")
if self.missing_values == "raise":
self._check_index_contains_na(X.index)
self.variables_ = None
else:
# find or check for datetime variables
self.variables_ = _find_or_check_datetime_variables(X, self.variables)
# check if datetime variables contains na
if self.missing_values == "raise":
_check_contains_na(X, self.variables_)
if self.features_to_extract is None:
self.features_to_extract_ = FEATURES_DEFAULT
elif isinstance(self.features_to_extract, str):
self.features_to_extract_ = FEATURES_SUPPORTED
else:
self.features_to_extract_ = self.features_to_extract
# save input features
self.feature_names_in_ = X.columns.tolist()
# save train set shape
self.n_features_in_ = X.shape[1]
return self
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
This transformer does not learn any parameter. Performs dataframe checks.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training input samples. Can be the entire dataframe, not just the
variables to transform.
y: pandas Series, or np.array. Default=None.
It is not needed in this transformer. You can pass y or None.
Raises
------
TypeError
- If the input is not a Pandas DataFrame
- If any user provided variables are not numerical
ValueError
If any of the reference variables contain null values and the
mathematical operation is 'div'.
Returns
-------
self
"""
# check input dataframe
X = _is_dataframe(X)
# check variables to combine are numerical
self.variables_to_combine = _find_or_check_numerical_variables(
X, self.variables_to_combine)
# check reference_variables are numerical
self.reference_variables = _find_or_check_numerical_variables(
X, self.reference_variables)
# check if dataset contains na
if self.missing_values == "raise":
_check_contains_na(X, self.reference_variables)
_check_contains_na(X, self.variables_to_combine)
_check_contains_inf(X, self.reference_variables)
_check_contains_inf(X, self.variables_to_combine)
# cannot divide by 0, as will result in error
if "div" in self.operations:
if X[self.reference_variables].isin([0]).any().any():
raise ValueError(
"Some of the reference variables contain 0 as values. Check and "
"remove those before using this transformer with div.")
self.n_features_in_ = X.shape[1]
return self
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
This transformer does not learn any parameter.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training input samples.
y: pandas Series, default=None
y is not needed in this transformer. You can pass y or None.
Raises
------
TypeError
If the input is not a Pandas DataFrame
Returns
-------
self
"""
X = _is_dataframe(X)
# find variables to be capped
if self.min_capping_dict is None and self.max_capping_dict:
self.variables_ = [x for x in self.max_capping_dict.keys()]
elif self.max_capping_dict is None and self.min_capping_dict:
self.variables_ = [x for x in self.min_capping_dict.keys()]
elif self.min_capping_dict and self.max_capping_dict:
tmp = self.min_capping_dict.copy()
tmp.update(self.max_capping_dict)
self.variables_ = [x for x in tmp.keys()]
if self.missing_values == "raise":
# check if dataset contains na
_check_contains_na(X, self.variables_)
_check_contains_inf(X, self.variables_)
# find or check for numerical variables
self.variables_ = _find_or_check_numerical_variables(
X, self.variables_)
if self.max_capping_dict is not None:
self.right_tail_caps_ = self.max_capping_dict
else:
self.right_tail_caps_ = {}
if self.min_capping_dict is not None:
self.left_tail_caps_ = self.min_capping_dict
else:
self.left_tail_caps_ = {}
self.n_features_in_ = X.shape[1]
return self
def fit(self, X, y=None):
"""
Learns the unique categories per variable. If top_categories is indicated,
it will learn the most popular categories. Alternatively, it learns all
unique categories per variable.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The training input samples.
Can be the entire dataframe, not just seleted variables.
y : pandas series, default=None
Target. It is not needed in this encoded. You can pass y or
None.
Attributes
----------
encoder_dict_: dictionary
The dictionary containing the categories for which dummy variables
will be created.
"""
# check input dataframe
X = _is_dataframe(X)
# find categorical variables or check that those entered by the user
# are of type object
self.variables = _find_categorical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
self.encoder_dict_ = {}
for var in self.variables:
if not self.top_categories:
if self.drop_last:
category_ls = [x for x in X[var].unique()]
self.encoder_dict_[var] = category_ls[:-1]
else:
self.encoder_dict_[var] = X[var].unique()
else:
self.encoder_dict_[var] = [
x for x in X[var].value_counts().sort_values(
ascending=False).head(self.top_categories).index
]
self.encoder_dict_ = _check_encoding_dictionary(self.encoder_dict_)
self.input_shape_ = X.shape
return self
def fit(self, X, y=None):
""" Learns the numbers to be used to replace the categories in each
variable.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The training input samples.
Can be the entire dataframe, not just the variables to be
encoded.
y : pandas series, default=None
The Target. Can be None if encoding_method = 'arbitrary'.
Otherwise, y needs to be passed when fitting the transformer.
"""
# check input dataframe
X = _is_dataframe(X)
# find categorical variables or check that those entered by the user
# are of type object
self.variables = _find_categorical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
# join target to predictor variables
if self.encoding_method == 'ordered':
if y is None:
raise ValueError(
'Please provide a target y for this encoding method')
temp = pd.concat([X, y], axis=1)
temp.columns = list(X.columns) + ['target']
# find mappings
self.encoder_dict_ = {}
for var in self.variables:
if self.encoding_method == 'ordered':
t = temp.groupby(
[var])['target'].mean().sort_values(ascending=True).index
elif self.encoding_method == 'arbitrary':
t = X[var].unique()
self.encoder_dict_[var] = {k: i for i, k in enumerate(t, 0)}
self.encoder_dict_ = _check_encoding_dictionary(self.encoder_dict_)
self.input_shape_ = X.shape
return self
def fit(self, X, y=None):
# check input dataframe
X = _is_dataframe(X)
# find or check for numerical variables
self.variables = _find_numerical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
return X
def _check_fit_input_and_variables(self, X: pd.DataFrame) -> pd.DataFrame:
# check input dataframe
X = _is_dataframe(X)
# find categorical variables or check variables entered by user are object
self.variables = _find_categorical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
return X
def transform(self, X: pd.DataFrame) -> pd.DataFrame:
"""Replace categories with the learned parameters.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features].
The dataset to transform.
Returns
-------
X_new: pandas dataframe of shape = [n_samples, n_features].
The dataframe containing the categories replaced by numbers.
"""
X = self._check_transform_input_and_state(X)
# check if dataset contains na
_check_contains_na(X, self.variables_)
# replace categories by the learned parameters
for feature in self.encoder_dict_.keys():
X[feature] = X[feature].map(self.encoder_dict_[feature])
# if original variables are cast as categorical, they will remain
# categorical after the encoding, and this is probably not desired
if pd.api.types.is_categorical_dtype(X[feature]):
if all(isinstance(x, int) for x in X[feature]):
X[feature] = X[feature].astype("int")
else:
X[feature] = X[feature].astype("float")
# check if NaN values were introduced by the encoding
if X[self.encoder_dict_.keys()].isnull().sum().sum() > 0:
# obtain the name(s) of the columns have null values
nan_columns = (X[self.encoder_dict_.keys()].columns[X[
self.encoder_dict_.keys()].isnull().any()].tolist())
if len(nan_columns) > 1:
nan_columns_str = ", ".join(nan_columns)
else:
nan_columns_str = nan_columns[0]
if self.errors == "ignore":
warnings.warn(
"During the encoding, NaN values were introduced in the feature(s) "
f"{nan_columns_str}.")
elif self.errors == "raise":
raise ValueError(
"During the encoding, NaN values were introduced in the feature(s) "
f"{nan_columns_str}.")
return X
def _check_na_and_inf(self, X: pd.DataFrame):
"""
Checks that the dataframe does not contain NaN or Infinite values.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The dataset for training or transformation.
"""
_check_contains_na(X, self.variables_)
_check_contains_inf(X, self.variables_)
return self
def _check_transform_input_and_state(self, X):
# Check method fit has been called
check_is_fitted(self)
# check that input is a dataframe
X = _is_dataframe(X)
# check if dataset contains na
_check_contains_na(X, self.variables)
# Check input data contains same number of columns as df used to fit
_check_input_matches_training_df(X, self.input_shape_[1])
return X
def fit(self, X, y=None):
"""
Learns the counts or frequencies which will be used to replace the categories.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The training input samples.
The user can pass the entire dataframe.
y : None
y is not needed in this encoder. You can pass y or None.
Attributes
----------
encoder_dict_: dictionary
Dictionary containing the {category: count / frequency} pairs for
each variable.
"""
# check input dataframe
X = _is_dataframe(X)
# find categorical variables or check that those entered by the user
# are of type object
self.variables = _find_categorical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
self.encoder_dict_ = {}
# learn encoding maps
for var in self.variables:
if self.encoding_method == 'count':
self.encoder_dict_[var] = X[var].value_counts().to_dict()
elif self.encoding_method == 'frequency':
n_obs = np.float(len(X))
self.encoder_dict_[var] = (X[var].value_counts() /
n_obs).to_dict()
self.encoder_dict_ = _check_encoding_dictionary(self.encoder_dict_)
self.input_shape_ = X.shape
return self
def fit(self, X, y):
"""
Learns the mean value of the target for each category of the variable.
Parameters
----------
X : pandas dataframe of shape = [n_samples, n_features]
The training input samples.
Can be the entire dataframe, not just the variables to be encoded.
y : pandas series
The target.
Attributes
----------
encoder_dict_: dictionary
The dictionary containing the {category: target mean} pairs used
to replace categories in every variable.
"""
# check input dataframe
X = _is_dataframe(X)
# find categorical variables or check that those entered by the user
# are of type object
self.variables = _find_categorical_variables(X, self.variables)
# check if dataset contains na
_check_contains_na(X, self.variables)
if y is None:
raise ValueError(
'Please provide a target y for this encoding method')
temp = pd.concat([X, y], axis=1)
temp.columns = list(X.columns) + ['target']
self.encoder_dict_ = {}
for var in self.variables:
self.encoder_dict_[var] = temp.groupby(
var)['target'].mean().to_dict()
self.encoder_dict_ = _check_encoding_dictionary(self.encoder_dict_)
self.input_shape_ = X.shape
return self
def transform(self, X):
# Check method fit has been called
check_is_fitted(self)
# check that input is a dataframe
X = _is_dataframe(X)
# check if dataset contains na
_check_contains_na(X, self.variables)
# Check that the dataframe contains the same number of columns
# than the dataframe used to fit the imputer.
_check_input_matches_training_df(X, self.input_shape_[1])
return X
def _check_transform_input_and_state(self, X):
# check if class was fitted
check_is_fitted(self)
# check that input is a dataframe
X = _is_dataframe(X)
if self.missing_values == "raise":
# check if dataset contains na
_check_contains_na(X, self.variables)
# Check that the dataframe contains the same number of columns
# than the dataframe used to fit the imputer.
_check_input_matches_training_df(X, self.input_shape_[1])
return X
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
This transformer does not learn any parameter.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training input samples. Can be the entire dataframe, not just the
variables to transform.
y: pandas Series, or np.array. Default=None.
It is not needed in this transformer. You can pass y or None.
"""
# check input dataframe
X = check_X(X)
# check variables to combine are numerical
self.variables_to_combine = _find_or_check_numerical_variables(
X, self.variables_to_combine)
# check reference_variables are numerical
self.reference_variables = _find_or_check_numerical_variables(
X, self.reference_variables)
# check if dataset contains na
if self.missing_values == "raise":
_check_contains_na(X, self.reference_variables)
_check_contains_na(X, self.variables_to_combine)
_check_contains_inf(X, self.reference_variables)
_check_contains_inf(X, self.variables_to_combine)
# cannot divide by 0, as will result in error
if "div" in self.operations:
if X[self.reference_variables].isin([0]).any().any():
raise ValueError(
"Some of the reference variables contain 0 as values. Check and "
"remove those before using this transformer with div.")
# save input features
self.feature_names_in_ = X.columns.tolist()
# save train set shape
self.n_features_in_ = X.shape[1]
return self
def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None):
"""
This transformer does not learn any parameter.
Check dataframe and variables. Checks that the user entered variables are in
the train set and cast as numerical.
Parameters
----------
X: pandas dataframe of shape = [n_samples, n_features]
The training dataset. Can be the entire dataframe, not just the
variables to be transformed.
y: None
y is not needed in this transformer. You can pass y or None.
Raises
------
TypeError
- If the input is not a Pandas DataFrame
- If any of the user provided variables are not numerical
ValueError
- If there are no numerical variables in the df or the df is empty
- If the variable(s) contain null values
Returns
-------
self
"""
# check input dataframe
X = _is_dataframe(X)
# find or check for numerical variables
variables = [x for x in self.binning_dict.keys()]
self.variables_ = _find_or_check_numerical_variables(X, variables)
# check if dataset contains na or inf
_check_contains_na(X, self.variables_)
_check_contains_inf(X, self.variables_)
# for consistency wit the rest of the discretisers, we add this attribute
self.binner_dict_ = self.binning_dict
self.n_features_in_ = X.shape[1]
return self
