Click here to view the next lesson.

Capítulo 3: Automatización de la ingeniería de características con pipelines

3.3 Ejercicios Prácticos para el Capítulo 3

Estos ejercicios te ayudarán a practicar la automatización del preprocesamiento de datos con las clases Pipeline y FeatureUnion de Scikit-learn. Cada ejercicio incluye una solución con código para orientación.

Ejercicio 1: Construir un Pipeline Simple con Escalado Estándar y Regresión Logística

Crea un pipeline que aplique Standard Scaling a las características numéricas Edad e Ingresos, y luego utilice Regresión Logística para clasificar una variable objetivo Deserción.

Carga el conjunto de datos y divídelo en características (X) y objetivo (y).
Crea un pipeline con StandardScaler y LogisticRegression.
Entrena el pipeline y evalúalo en el conjunto de prueba.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd

# Sample dataset
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Features and target
X = df[['Age', 'Income']]
y = df['Churn']

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Solution: Create a pipeline with StandardScaler and LogisticRegression
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('log_reg', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X_train, y_train)

# Make predictions and evaluate
y_pred = pipeline.predict(X_test)
print("Model Accuracy:", accuracy_score(y_test, y_pred))

En esta solución:

El pipeline automatiza los pasos de escalado y entrenamiento, y se calcula la precisión para evaluar el rendimiento del modelo.

Ejercicio 2: Construir un Pipeline con Imputación y Codificación One-Hot

Amplía el pipeline para manejar valores faltantes en la columna Edad y aplica OneHotEncoding a la característica categórica Género.

Agrega un imputador de valores faltantes para Edad y codificación one-hot para Género en el pipeline.
Entrena el modelo y observa el conjunto de características transformado.

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# Sample dataset with missing values and a categorical feature
data = {'Age': [25, None, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Gender': ['Male', 'Female', 'Female', 'Male', 'Female'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income', 'Gender']]
y = df['Churn']

# Define transformers for numeric and categorical features
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('onehot', OneHotEncoder())
])

# Solution: Create ColumnTransformer for handling numeric and categorical features
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, ['Age', 'Income']),
        ('cat', categorical_transformer, ['Gender'])
    ])

# Create pipeline with preprocessor and logistic regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline and view transformed features
pipeline.fit(X, y)
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

El pipeline maneja los valores faltantes en Edad y codifica Género utilizando codificación one-hot, produciendo un conjunto de características completamente transformado.

Ejercicio 3: Usar FeatureUnion para Combinar Escalado y Características Polinómicas

Crea un pipeline que utilice FeatureUnion para aplicar tanto Standard Scaling como Características Polinómicas a la columna Ingresos, y luego aplica Regresión Logística.

Define un FeatureUnion con escalado y generación de características polinómicas para Ingresos.
Integra FeatureUnion con otras transformaciones en el pipeline.

from sklearn.pipeline import FeatureUnion
from sklearn.preprocessing import PolynomialFeatures

# Sample dataset with a numeric feature
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income']]
y = df['Churn']

# FeatureUnion for scaling and polynomial features for Income
numeric_features = ['Income']
numeric_transformers = FeatureUnion([
    ('scaler', StandardScaler()),
    ('poly', PolynomialFeatures(degree=2))
])

# ColumnTransformer to handle both Age and Income transformations
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformers, numeric_features),
        ('age_scaler', StandardScaler(), ['Age'])
    ])

# Solution: Create pipeline with FeatureUnion and Logistic Regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

FeatureUnion permite aplicar tanto escalado como generación de características polinómicas para Ingresos, demostrando cómo manejar múltiples transformaciones en la misma característica.

Ejercicio 4: Construir un Transformador Personalizado para Codificación de Frecuencia

Crea un pipeline que utilice un transformador personalizado para realizar codificación de frecuencia en la columna Ocupación, junto con escalado estándar para las características numéricas.

Define un transformador personalizado para la codificación de frecuencia.
Combina este transformador con otros pasos de preprocesamiento en un pipeline.

from sklearn.base import BaseEstimator, TransformerMixin

# Sample dataset with a categorical feature for frequency encoding
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Occupation': ['Engineer', 'Doctor', 'Artist', 'Engineer', 'Artist'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Custom transformer for frequency encoding
class FrequencyEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, column):
        self.column = column

    def fit(self, X, y=None):
        self.freq_encoding = X[self.column].value_counts(normalize=True).to_dict()
        return self

    def transform(self, X):
        X_copy = X.copy()
        X_copy[self.column] = X_copy[self.column].map(self.freq_encoding)
        return X_copy[[self.column]]

# Define features and target
X = df[['Age', 'Income', 'Occupation']]
y = df['Churn']

# Solution: Apply frequency encoding and scaling in a pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ('age_scaler', StandardScaler(), ['Age', 'Income']),
        ('occupation_encoder', FrequencyEncoder(column='Occupation'), ['Occupation'])
    ])

pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

Se crea un transformador personalizado para realizar la codificación de frecuencia en Ocupación, demostrando cómo incorporar transformaciones personalizadas en un pipeline.

Estos ejercicios abarcan una variedad de técnicas automatizadas de preprocesamiento de datos, desde el escalado básico hasta la ingeniería avanzada de características con FeatureUnion y transformadores personalizados. Al completar estos ejercicios, obtendrás experiencia práctica en el uso de las herramientas de pipeline de Scikit-learn para simplificar flujos de trabajo de datos complejos y mejorar la precisión del modelo.

3.3 Ejercicios Prácticos para el Capítulo 3

Ejercicio 1: Construir un Pipeline Simple con Escalado Estándar y Regresión Logística

Carga el conjunto de datos y divídelo en características (X) y objetivo (y).
Crea un pipeline con StandardScaler y LogisticRegression.
Entrena el pipeline y evalúalo en el conjunto de prueba.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd

# Sample dataset
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Features and target
X = df[['Age', 'Income']]
y = df['Churn']

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Solution: Create a pipeline with StandardScaler and LogisticRegression
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('log_reg', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X_train, y_train)

# Make predictions and evaluate
y_pred = pipeline.predict(X_test)
print("Model Accuracy:", accuracy_score(y_test, y_pred))

En esta solución:

El pipeline automatiza los pasos de escalado y entrenamiento, y se calcula la precisión para evaluar el rendimiento del modelo.

Ejercicio 2: Construir un Pipeline con Imputación y Codificación One-Hot

Amplía el pipeline para manejar valores faltantes en la columna Edad y aplica OneHotEncoding a la característica categórica Género.

Agrega un imputador de valores faltantes para Edad y codificación one-hot para Género en el pipeline.
Entrena el modelo y observa el conjunto de características transformado.

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# Sample dataset with missing values and a categorical feature
data = {'Age': [25, None, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Gender': ['Male', 'Female', 'Female', 'Male', 'Female'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income', 'Gender']]
y = df['Churn']

# Define transformers for numeric and categorical features
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('onehot', OneHotEncoder())
])

# Solution: Create ColumnTransformer for handling numeric and categorical features
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, ['Age', 'Income']),
        ('cat', categorical_transformer, ['Gender'])
    ])

# Create pipeline with preprocessor and logistic regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline and view transformed features
pipeline.fit(X, y)
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

El pipeline maneja los valores faltantes en Edad y codifica Género utilizando codificación one-hot, produciendo un conjunto de características completamente transformado.

Ejercicio 3: Usar FeatureUnion para Combinar Escalado y Características Polinómicas

Crea un pipeline que utilice FeatureUnion para aplicar tanto Standard Scaling como Características Polinómicas a la columna Ingresos, y luego aplica Regresión Logística.

Define un FeatureUnion con escalado y generación de características polinómicas para Ingresos.
Integra FeatureUnion con otras transformaciones en el pipeline.

from sklearn.pipeline import FeatureUnion
from sklearn.preprocessing import PolynomialFeatures

# Sample dataset with a numeric feature
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income']]
y = df['Churn']

# FeatureUnion for scaling and polynomial features for Income
numeric_features = ['Income']
numeric_transformers = FeatureUnion([
    ('scaler', StandardScaler()),
    ('poly', PolynomialFeatures(degree=2))
])

# ColumnTransformer to handle both Age and Income transformations
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformers, numeric_features),
        ('age_scaler', StandardScaler(), ['Age'])
    ])

# Solution: Create pipeline with FeatureUnion and Logistic Regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

FeatureUnion permite aplicar tanto escalado como generación de características polinómicas para Ingresos, demostrando cómo manejar múltiples transformaciones en la misma característica.

Ejercicio 4: Construir un Transformador Personalizado para Codificación de Frecuencia

Define un transformador personalizado para la codificación de frecuencia.
Combina este transformador con otros pasos de preprocesamiento en un pipeline.

from sklearn.base import BaseEstimator, TransformerMixin

# Sample dataset with a categorical feature for frequency encoding
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Occupation': ['Engineer', 'Doctor', 'Artist', 'Engineer', 'Artist'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Custom transformer for frequency encoding
class FrequencyEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, column):
        self.column = column

    def fit(self, X, y=None):
        self.freq_encoding = X[self.column].value_counts(normalize=True).to_dict()
        return self

    def transform(self, X):
        X_copy = X.copy()
        X_copy[self.column] = X_copy[self.column].map(self.freq_encoding)
        return X_copy[[self.column]]

# Define features and target
X = df[['Age', 'Income', 'Occupation']]
y = df['Churn']

# Solution: Apply frequency encoding and scaling in a pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ('age_scaler', StandardScaler(), ['Age', 'Income']),
        ('occupation_encoder', FrequencyEncoder(column='Occupation'), ['Occupation'])
    ])

pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

Se crea un transformador personalizado para realizar la codificación de frecuencia en Ocupación, demostrando cómo incorporar transformaciones personalizadas en un pipeline.

3.3 Ejercicios Prácticos para el Capítulo 3

Ejercicio 1: Construir un Pipeline Simple con Escalado Estándar y Regresión Logística

Carga el conjunto de datos y divídelo en características (X) y objetivo (y).
Crea un pipeline con StandardScaler y LogisticRegression.
Entrena el pipeline y evalúalo en el conjunto de prueba.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd

# Sample dataset
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Features and target
X = df[['Age', 'Income']]
y = df['Churn']

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Solution: Create a pipeline with StandardScaler and LogisticRegression
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('log_reg', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X_train, y_train)

# Make predictions and evaluate
y_pred = pipeline.predict(X_test)
print("Model Accuracy:", accuracy_score(y_test, y_pred))

En esta solución:

El pipeline automatiza los pasos de escalado y entrenamiento, y se calcula la precisión para evaluar el rendimiento del modelo.

Ejercicio 2: Construir un Pipeline con Imputación y Codificación One-Hot

Amplía el pipeline para manejar valores faltantes en la columna Edad y aplica OneHotEncoding a la característica categórica Género.

Agrega un imputador de valores faltantes para Edad y codificación one-hot para Género en el pipeline.
Entrena el modelo y observa el conjunto de características transformado.

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# Sample dataset with missing values and a categorical feature
data = {'Age': [25, None, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Gender': ['Male', 'Female', 'Female', 'Male', 'Female'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income', 'Gender']]
y = df['Churn']

# Define transformers for numeric and categorical features
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('onehot', OneHotEncoder())
])

# Solution: Create ColumnTransformer for handling numeric and categorical features
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, ['Age', 'Income']),
        ('cat', categorical_transformer, ['Gender'])
    ])

# Create pipeline with preprocessor and logistic regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline and view transformed features
pipeline.fit(X, y)
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

El pipeline maneja los valores faltantes en Edad y codifica Género utilizando codificación one-hot, produciendo un conjunto de características completamente transformado.

Ejercicio 3: Usar FeatureUnion para Combinar Escalado y Características Polinómicas

Crea un pipeline que utilice FeatureUnion para aplicar tanto Standard Scaling como Características Polinómicas a la columna Ingresos, y luego aplica Regresión Logística.

Define un FeatureUnion con escalado y generación de características polinómicas para Ingresos.
Integra FeatureUnion con otras transformaciones en el pipeline.

from sklearn.pipeline import FeatureUnion
from sklearn.preprocessing import PolynomialFeatures

# Sample dataset with a numeric feature
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income']]
y = df['Churn']

# FeatureUnion for scaling and polynomial features for Income
numeric_features = ['Income']
numeric_transformers = FeatureUnion([
    ('scaler', StandardScaler()),
    ('poly', PolynomialFeatures(degree=2))
])

# ColumnTransformer to handle both Age and Income transformations
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformers, numeric_features),
        ('age_scaler', StandardScaler(), ['Age'])
    ])

# Solution: Create pipeline with FeatureUnion and Logistic Regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

FeatureUnion permite aplicar tanto escalado como generación de características polinómicas para Ingresos, demostrando cómo manejar múltiples transformaciones en la misma característica.

Ejercicio 4: Construir un Transformador Personalizado para Codificación de Frecuencia

Define un transformador personalizado para la codificación de frecuencia.
Combina este transformador con otros pasos de preprocesamiento en un pipeline.

from sklearn.base import BaseEstimator, TransformerMixin

# Sample dataset with a categorical feature for frequency encoding
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Occupation': ['Engineer', 'Doctor', 'Artist', 'Engineer', 'Artist'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Custom transformer for frequency encoding
class FrequencyEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, column):
        self.column = column

    def fit(self, X, y=None):
        self.freq_encoding = X[self.column].value_counts(normalize=True).to_dict()
        return self

    def transform(self, X):
        X_copy = X.copy()
        X_copy[self.column] = X_copy[self.column].map(self.freq_encoding)
        return X_copy[[self.column]]

# Define features and target
X = df[['Age', 'Income', 'Occupation']]
y = df['Churn']

# Solution: Apply frequency encoding and scaling in a pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ('age_scaler', StandardScaler(), ['Age', 'Income']),
        ('occupation_encoder', FrequencyEncoder(column='Occupation'), ['Occupation'])
    ])

pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

Se crea un transformador personalizado para realizar la codificación de frecuencia en Ocupación, demostrando cómo incorporar transformaciones personalizadas en un pipeline.

3.3 Ejercicios Prácticos para el Capítulo 3

Ejercicio 1: Construir un Pipeline Simple con Escalado Estándar y Regresión Logística

Carga el conjunto de datos y divídelo en características (X) y objetivo (y).
Crea un pipeline con StandardScaler y LogisticRegression.
Entrena el pipeline y evalúalo en el conjunto de prueba.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd

# Sample dataset
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Features and target
X = df[['Age', 'Income']]
y = df['Churn']

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Solution: Create a pipeline with StandardScaler and LogisticRegression
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('log_reg', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X_train, y_train)

# Make predictions and evaluate
y_pred = pipeline.predict(X_test)
print("Model Accuracy:", accuracy_score(y_test, y_pred))

En esta solución:

El pipeline automatiza los pasos de escalado y entrenamiento, y se calcula la precisión para evaluar el rendimiento del modelo.

Ejercicio 2: Construir un Pipeline con Imputación y Codificación One-Hot

Amplía el pipeline para manejar valores faltantes en la columna Edad y aplica OneHotEncoding a la característica categórica Género.

Agrega un imputador de valores faltantes para Edad y codificación one-hot para Género en el pipeline.
Entrena el modelo y observa el conjunto de características transformado.

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# Sample dataset with missing values and a categorical feature
data = {'Age': [25, None, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Gender': ['Male', 'Female', 'Female', 'Male', 'Female'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income', 'Gender']]
y = df['Churn']

# Define transformers for numeric and categorical features
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('onehot', OneHotEncoder())
])

# Solution: Create ColumnTransformer for handling numeric and categorical features
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, ['Age', 'Income']),
        ('cat', categorical_transformer, ['Gender'])
    ])

# Create pipeline with preprocessor and logistic regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline and view transformed features
pipeline.fit(X, y)
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

El pipeline maneja los valores faltantes en Edad y codifica Género utilizando codificación one-hot, produciendo un conjunto de características completamente transformado.

Ejercicio 3: Usar FeatureUnion para Combinar Escalado y Características Polinómicas

Crea un pipeline que utilice FeatureUnion para aplicar tanto Standard Scaling como Características Polinómicas a la columna Ingresos, y luego aplica Regresión Logística.

Define un FeatureUnion con escalado y generación de características polinómicas para Ingresos.
Integra FeatureUnion con otras transformaciones en el pipeline.

from sklearn.pipeline import FeatureUnion
from sklearn.preprocessing import PolynomialFeatures

# Sample dataset with a numeric feature
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Define features and target
X = df[['Age', 'Income']]
y = df['Churn']

# FeatureUnion for scaling and polynomial features for Income
numeric_features = ['Income']
numeric_transformers = FeatureUnion([
    ('scaler', StandardScaler()),
    ('poly', PolynomialFeatures(degree=2))
])

# ColumnTransformer to handle both Age and Income transformations
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformers, numeric_features),
        ('age_scaler', StandardScaler(), ['Age'])
    ])

# Solution: Create pipeline with FeatureUnion and Logistic Regression
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

FeatureUnion permite aplicar tanto escalado como generación de características polinómicas para Ingresos, demostrando cómo manejar múltiples transformaciones en la misma característica.

Ejercicio 4: Construir un Transformador Personalizado para Codificación de Frecuencia

Define un transformador personalizado para la codificación de frecuencia.
Combina este transformador con otros pasos de preprocesamiento en un pipeline.

from sklearn.base import BaseEstimator, TransformerMixin

# Sample dataset with a categorical feature for frequency encoding
data = {'Age': [25, 32, 47, 51, 62],
        'Income': [50000, 65000, 85000, 90000, 120000],
        'Occupation': ['Engineer', 'Doctor', 'Artist', 'Engineer', 'Artist'],
        'Churn': [0, 0, 1, 1, 1]}
df = pd.DataFrame(data)

# Custom transformer for frequency encoding
class FrequencyEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, column):
        self.column = column

    def fit(self, X, y=None):
        self.freq_encoding = X[self.column].value_counts(normalize=True).to_dict()
        return self

    def transform(self, X):
        X_copy = X.copy()
        X_copy[self.column] = X_copy[self.column].map(self.freq_encoding)
        return X_copy[[self.column]]

# Define features and target
X = df[['Age', 'Income', 'Occupation']]
y = df['Churn']

# Solution: Apply frequency encoding and scaling in a pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ('age_scaler', StandardScaler(), ['Age', 'Income']),
        ('occupation_encoder', FrequencyEncoder(column='Occupation'), ['Occupation'])
    ])

pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

# Fit the pipeline
pipeline.fit(X, y)

# View transformed feature set
print("\\nTransformed Feature Set (Sample):")
print(preprocessor.fit_transform(X)[:5])

En esta solución:

Se crea un transformador personalizado para realizar la codificación de frecuencia en Ocupación, demostrando cómo incorporar transformaciones personalizadas en un pipeline.

Compra este libro