scikit-learn

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.preprocessing import PowerTransformer
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression, Ridge, RidgeCV
from sklearn.model_selection import GridSearchCV, KFold

from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression

X, y = make_regression(n_features=1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)

from sklearn.preprocessing import PolynomialFeatures, FunctionTransformer

df = pd.DataFrame({'category': ['a', 'b', 'c'], 'numeric': np.random.random(size=3)})
display(df)

def pandas_polynomial_features(X):
    """ Wrapper for calling PolynomialFeatures while preserving
    index and column names from input DataFrame. """
    poly_tx = PolynomialFeatures(degree=2, include_bias=False).fit(X)
    poly_cols = poly_tx.get_feature_names_out(input_features=X.columns)
    return pd.DataFrame(poly_tx.transform(X), index=X.index, columns=poly_cols)

PandasPolynomialFeatures = FunctionTransformer(pandas_polynomial_features, validate=False)

numeric_cols = df.select_dtypes(np.number).dtypes.index.values.tolist()
PandasPolynomialFeatures.fit_transform(df[numeric_cols])

df = pd.DataFrame({'home_city': np.random.choice(['toronto', 'paris', 'london'], size=5),
                   'fav_city': np.random.choice(['toronto', 'paris', 'london'], size=5)}, dtype='category')

display(df)

from sklearn.preprocessing import OneHotEncoder

def pandas_one_hot_encoder(X):
    
    """ Wrapper for calling PolynomialFeatures while preserving index and column names from input DataFrame. """

    fit_obj = OneHotEncoder().fit(X)
    nested_output_col_names = fit_obj.categories_
    flat_output_col_names = []
    
    for cat_col, corresp_enc_cols in zip(X.columns, nested_output_col_names):
        stem = ''.join([x[0] for x in cat_col.split('_')]) + '_is_'
        flat_output_col_names.extend(stem + corresp_enc_cols)
    
    return pd.DataFrame(fit_obj.transform(X).toarray(),
                        index=X.index,
                        columns=flat_output_col_names)

PandasOneHotEncoder = FunctionTransformer(pandas_one_hot_encoder, validate=False)
PandasOneHotEncoder.fit_transform(df).head()

df = pd.DataFrame({'home_city': np.random.choice(['toronto', 'paris', 'london'], size=5),
                   'fav_city': np.random.choice(['toronto', 'paris', 'london'], size=5)}, dtype='category')

df['age'] = np.random.randint(80, size=5)
display(df)

numeric_cols = df.dtypes.apply(lambda x: x.kind in 'bifc').reset_index(drop=True).loc[lambda x: x == True].index
cat_cols = (df.dtypes == 'category').reset_index(drop=True).loc[lambda x: x == True].index

col_tx = ColumnTransformer(transformers=[
    ('num', PowerTransformer(), numeric_cols),
    ('cat', OneHotEncoder(drop='first', handle_unknown='error'), cat_cols)
])

pipe = Pipeline([
    ('col_tx', col_tx),
    ('model', LinearRegression())
])

pipe.fit(df, [0, 1, 0, 1, 0]);

from sklearn.datasets import make_regression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

def find_best_degrees(X, y, degrees=range(1, 11)):
    """ Example of grid search on parameters of an upstream transformation step in a pipeline. """

    pipe = Pipeline([
        ('poly_tx', PolynomialFeatures(include_bias=False)),
        ('model', make_pipeline(StandardScaler(with_mean=False), Ridge()))
    ])

    param_grid = {'poly_tx__degree': degrees}
    search = GridSearchCV(pipe, param_grid, cv=KFold(n_splits=5, shuffle=True)).fit(X, y)

    avg_scores = search.cv_results_['mean_test_score']
    std_scores = search.cv_results_['std_test_score']

    fig, ax = plt.subplots(figsize=(8, 4), dpi=100)
    ax.plot(degrees, avg_scores, label='$R^2$')
    ax.fill_between(degrees, avg_scores-std_scores, avg_scores+std_scores, alpha=0.2)
    ax.set_title('Model fit by polynomial degree')
    ax.set_ylabel('$R^2$')
    ax.set_xlabel('Polynomial degree')

X, y = make_regression(n_features=1)
find_best_degrees(X, y)