Click here to view the next lesson.

Capítulo 2: Optimización de Flujos de Trabajo de Datos

2.4 Ejercicios Prácticos para el Capítulo 2: Optimización de Flujos de Trabajo de Datos

Ahora que has completado el Capítulo 2, es hora de practicar lo que has aprendido con estos ejercicios. Los siguientes ejercicios están diseñados para ayudarte a aplicar técnicas avanzadas de manipulación de datos con Pandas, mejorar el rendimiento con NumPy y combinar herramientas para un análisis eficiente. Cada ejercicio incluye un bloque de código de solución para ayudarte a verificar tu trabajo.

Ejercicio 1: Manipulación Avanzada de Datos con Pandas

Tienes un conjunto de datos de pedidos en línea de una tienda de comercio electrónico. Tu tarea es:

Filtrar el conjunto de datos para incluir solo pedidos donde el monto del pedido es mayor a $200.
Agrupar el conjunto de datos por Categoría y CustomerID para calcular los montos totales y promedios de pedido para cada grupo.
Crear una tabla dinámica de modo que cada Categoría sea una columna y las filas representen cada CustomerID.

import pandas as pd

# Sample data: Online orders
data = {'OrderID': [1, 2, 3, 4, 5],
        'CustomerID': [101, 102, 103, 101, 104],
        'Category': ['Electronics', 'Clothing', 'Electronics', 'Furniture', 'Furniture'],
        'OrderAmount': [250, 120, 300, 400, 500]}

df = pd.DataFrame(data)

# Solution
# Step 1: Filter orders where OrderAmount > 200
filtered_df = df[df['OrderAmount'] > 200]

# Step 2: Group by Category and CustomerID, and calculate total and average order amounts
grouped_df = filtered_df.groupby(['Category', 'CustomerID']).agg(
    TotalAmount=('OrderAmount', 'sum'),
    AvgAmount=('OrderAmount', 'mean')
).reset_index()

# Step 3: Pivot the dataset so that Category is a column
pivot_df = grouped_df.pivot(index='CustomerID', columns='Category', values='TotalAmount').fillna(0)

print(pivot_df)

Ejercicio 2: Mejorando el Rendimiento con NumPy

Dado un arreglo de precios de productos, tu tarea es:

Aplicar una transformación logarítmica para normalizar los precios.
Usar broadcasting para aplicar un descuento del 20% a cada precio.
Calcular el precio promedio con descuento usando las funciones vectorizadas de NumPy.

import numpy as np

# Sample data: Product prices
prices = np.array([100, 150, 200, 250, 300])

# Solution
# Step 1: Apply a logarithmic transformation
log_prices = np.log(prices)

# Step 2: Apply a 20% discount using broadcasting
discounted_prices = prices * 0.80

# Step 3: Calculate the average discounted price
average_discounted_price = np.mean(discounted_prices)

print("Logarithmic Prices:", log_prices)
print("Discounted Prices:", discounted_prices)
print("Average Discounted Price:", average_discounted_price)

Ejercicio 3: Combinando Pandas y NumPy para Ingeniería de Características

Tienes un conjunto de datos de transacciones de clientes, que incluye el monto de compra y el descuento recibido. Tu tarea es:

Llenar los valores faltantes en las columnas PurchaseAmount y Discount con la media de cada columna.
Crear una nueva característica, NetPurchase, que sea el monto de la compra después de aplicar el descuento.
Usar NumPy para crear una característica de interacción multiplicando las columnas PurchaseAmount y Discount.

import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Fill missing values
df['PurchaseAmount'].fillna(df['PurchaseAmount'].mean(), inplace=True)
df['Discount'].fillna(df['Discount'].mean(), inplace=True)

# Step 2: Create NetPurchase feature
df['NetPurchase'] = df['PurchaseAmount'] - df['Discount']

# Step 3: Create an interaction feature using NumPy
df['Interaction_Purchase_Discount'] = df['PurchaseAmount'] * df['Discount']

print(df)

Ejercicio 4: Construcción de un Modelo de Clasificación con Scikit-learn

Tienes un conjunto de datos de transacciones de clientes. Tu tarea es:

Crear una variable objetivo que marque las compras mayores a $300 como alto valor.
Usar Scikit-learn para dividir los datos en conjuntos de entrenamiento y prueba.
Construir un modelo de clasificación con Random Forest para predecir compras de alto valor.
Evaluar el modelo calculando la precisión en el conjunto de prueba.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, 350, 300, 400, 150],
        'Discount': [10, 15, 20, 5, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Create target variable (high value if PurchaseAmount > 300)
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)

# Step 2: Define features and target
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 4: Build and train a Random Forest model
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)

# Step 5: Predict and evaluate accuracy on the test set
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Model Accuracy: {accuracy:.2f}")

Ejercicio 5: Uso de Pipelines de Scikit-learn para Flujos de Trabajo Eficientes

Tu tarea es crear un flujo de trabajo eficiente para los datos de transacciones de clientes. Tus tareas son:

Crear un pipeline de Scikit-learn que impute los valores faltantes, escale las características y entrene un modelo de Random Forest.
Entrenar el pipeline con el conjunto de datos y evaluar el desempeño del modelo.

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Define features and target
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 2: Create the pipeline
pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),  # Impute missing values
    ('scaler', StandardScaler()),  # Scale features
    ('classifier', RandomForestClassifier(random_state=42))  # Train Random Forest model
])

# Step 3: Train the pipeline
pipeline.fit(X_train, y_train)

# Step 4: Make predictions and evaluate the model
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Pipeline Model Accuracy: {accuracy:.2f}")

Estas prácticas te permitirán aplicar los conceptos cubiertos en el Capítulo 2, brindándote experiencia práctica en la manipulación avanzada de datos, mejoras de rendimiento con NumPy y creación de flujos de trabajo eficientes usando Scikit-learn. ¡Sigue practicando para profundizar tu comprensión!

2.4 Ejercicios Prácticos para el Capítulo 2: Optimización de Flujos de Trabajo de Datos

Ejercicio 1: Manipulación Avanzada de Datos con Pandas

Tienes un conjunto de datos de pedidos en línea de una tienda de comercio electrónico. Tu tarea es:

Filtrar el conjunto de datos para incluir solo pedidos donde el monto del pedido es mayor a $200.
Agrupar el conjunto de datos por Categoría y CustomerID para calcular los montos totales y promedios de pedido para cada grupo.
Crear una tabla dinámica de modo que cada Categoría sea una columna y las filas representen cada CustomerID.

import pandas as pd

# Sample data: Online orders
data = {'OrderID': [1, 2, 3, 4, 5],
        'CustomerID': [101, 102, 103, 101, 104],
        'Category': ['Electronics', 'Clothing', 'Electronics', 'Furniture', 'Furniture'],
        'OrderAmount': [250, 120, 300, 400, 500]}

df = pd.DataFrame(data)

# Solution
# Step 1: Filter orders where OrderAmount > 200
filtered_df = df[df['OrderAmount'] > 200]

# Step 2: Group by Category and CustomerID, and calculate total and average order amounts
grouped_df = filtered_df.groupby(['Category', 'CustomerID']).agg(
    TotalAmount=('OrderAmount', 'sum'),
    AvgAmount=('OrderAmount', 'mean')
).reset_index()

# Step 3: Pivot the dataset so that Category is a column
pivot_df = grouped_df.pivot(index='CustomerID', columns='Category', values='TotalAmount').fillna(0)

print(pivot_df)

Ejercicio 2: Mejorando el Rendimiento con NumPy

Dado un arreglo de precios de productos, tu tarea es:

Aplicar una transformación logarítmica para normalizar los precios.
Usar broadcasting para aplicar un descuento del 20% a cada precio.
Calcular el precio promedio con descuento usando las funciones vectorizadas de NumPy.

import numpy as np

# Sample data: Product prices
prices = np.array([100, 150, 200, 250, 300])

# Solution
# Step 1: Apply a logarithmic transformation
log_prices = np.log(prices)

# Step 2: Apply a 20% discount using broadcasting
discounted_prices = prices * 0.80

# Step 3: Calculate the average discounted price
average_discounted_price = np.mean(discounted_prices)

print("Logarithmic Prices:", log_prices)
print("Discounted Prices:", discounted_prices)
print("Average Discounted Price:", average_discounted_price)

Ejercicio 3: Combinando Pandas y NumPy para Ingeniería de Características

Tienes un conjunto de datos de transacciones de clientes, que incluye el monto de compra y el descuento recibido. Tu tarea es:

Llenar los valores faltantes en las columnas PurchaseAmount y Discount con la media de cada columna.
Crear una nueva característica, NetPurchase, que sea el monto de la compra después de aplicar el descuento.
Usar NumPy para crear una característica de interacción multiplicando las columnas PurchaseAmount y Discount.

import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Fill missing values
df['PurchaseAmount'].fillna(df['PurchaseAmount'].mean(), inplace=True)
df['Discount'].fillna(df['Discount'].mean(), inplace=True)

# Step 2: Create NetPurchase feature
df['NetPurchase'] = df['PurchaseAmount'] - df['Discount']

# Step 3: Create an interaction feature using NumPy
df['Interaction_Purchase_Discount'] = df['PurchaseAmount'] * df['Discount']

print(df)

Ejercicio 4: Construcción de un Modelo de Clasificación con Scikit-learn

Tienes un conjunto de datos de transacciones de clientes. Tu tarea es:

Crear una variable objetivo que marque las compras mayores a $300 como alto valor.
Usar Scikit-learn para dividir los datos en conjuntos de entrenamiento y prueba.
Construir un modelo de clasificación con Random Forest para predecir compras de alto valor.
Evaluar el modelo calculando la precisión en el conjunto de prueba.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, 350, 300, 400, 150],
        'Discount': [10, 15, 20, 5, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Create target variable (high value if PurchaseAmount > 300)
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)

# Step 2: Define features and target
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 4: Build and train a Random Forest model
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)

# Step 5: Predict and evaluate accuracy on the test set
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Model Accuracy: {accuracy:.2f}")

Ejercicio 5: Uso de Pipelines de Scikit-learn para Flujos de Trabajo Eficientes

Tu tarea es crear un flujo de trabajo eficiente para los datos de transacciones de clientes. Tus tareas son:

Crear un pipeline de Scikit-learn que impute los valores faltantes, escale las características y entrene un modelo de Random Forest.
Entrenar el pipeline con el conjunto de datos y evaluar el desempeño del modelo.

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Define features and target
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 2: Create the pipeline
pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),  # Impute missing values
    ('scaler', StandardScaler()),  # Scale features
    ('classifier', RandomForestClassifier(random_state=42))  # Train Random Forest model
])

# Step 3: Train the pipeline
pipeline.fit(X_train, y_train)

# Step 4: Make predictions and evaluate the model
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Pipeline Model Accuracy: {accuracy:.2f}")

2.4 Ejercicios Prácticos para el Capítulo 2: Optimización de Flujos de Trabajo de Datos

Ejercicio 1: Manipulación Avanzada de Datos con Pandas

Tienes un conjunto de datos de pedidos en línea de una tienda de comercio electrónico. Tu tarea es:

Filtrar el conjunto de datos para incluir solo pedidos donde el monto del pedido es mayor a $200.
Agrupar el conjunto de datos por Categoría y CustomerID para calcular los montos totales y promedios de pedido para cada grupo.
Crear una tabla dinámica de modo que cada Categoría sea una columna y las filas representen cada CustomerID.

import pandas as pd

# Sample data: Online orders
data = {'OrderID': [1, 2, 3, 4, 5],
        'CustomerID': [101, 102, 103, 101, 104],
        'Category': ['Electronics', 'Clothing', 'Electronics', 'Furniture', 'Furniture'],
        'OrderAmount': [250, 120, 300, 400, 500]}

df = pd.DataFrame(data)

# Solution
# Step 1: Filter orders where OrderAmount > 200
filtered_df = df[df['OrderAmount'] > 200]

# Step 2: Group by Category and CustomerID, and calculate total and average order amounts
grouped_df = filtered_df.groupby(['Category', 'CustomerID']).agg(
    TotalAmount=('OrderAmount', 'sum'),
    AvgAmount=('OrderAmount', 'mean')
).reset_index()

# Step 3: Pivot the dataset so that Category is a column
pivot_df = grouped_df.pivot(index='CustomerID', columns='Category', values='TotalAmount').fillna(0)

print(pivot_df)

Ejercicio 2: Mejorando el Rendimiento con NumPy

Dado un arreglo de precios de productos, tu tarea es:

Aplicar una transformación logarítmica para normalizar los precios.
Usar broadcasting para aplicar un descuento del 20% a cada precio.
Calcular el precio promedio con descuento usando las funciones vectorizadas de NumPy.

import numpy as np

# Sample data: Product prices
prices = np.array([100, 150, 200, 250, 300])

# Solution
# Step 1: Apply a logarithmic transformation
log_prices = np.log(prices)

# Step 2: Apply a 20% discount using broadcasting
discounted_prices = prices * 0.80

# Step 3: Calculate the average discounted price
average_discounted_price = np.mean(discounted_prices)

print("Logarithmic Prices:", log_prices)
print("Discounted Prices:", discounted_prices)
print("Average Discounted Price:", average_discounted_price)

Ejercicio 3: Combinando Pandas y NumPy para Ingeniería de Características

Tienes un conjunto de datos de transacciones de clientes, que incluye el monto de compra y el descuento recibido. Tu tarea es:

Llenar los valores faltantes en las columnas PurchaseAmount y Discount con la media de cada columna.
Crear una nueva característica, NetPurchase, que sea el monto de la compra después de aplicar el descuento.
Usar NumPy para crear una característica de interacción multiplicando las columnas PurchaseAmount y Discount.

import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Fill missing values
df['PurchaseAmount'].fillna(df['PurchaseAmount'].mean(), inplace=True)
df['Discount'].fillna(df['Discount'].mean(), inplace=True)

# Step 2: Create NetPurchase feature
df['NetPurchase'] = df['PurchaseAmount'] - df['Discount']

# Step 3: Create an interaction feature using NumPy
df['Interaction_Purchase_Discount'] = df['PurchaseAmount'] * df['Discount']

print(df)

Ejercicio 4: Construcción de un Modelo de Clasificación con Scikit-learn

Tienes un conjunto de datos de transacciones de clientes. Tu tarea es:

Crear una variable objetivo que marque las compras mayores a $300 como alto valor.
Usar Scikit-learn para dividir los datos en conjuntos de entrenamiento y prueba.
Construir un modelo de clasificación con Random Forest para predecir compras de alto valor.
Evaluar el modelo calculando la precisión en el conjunto de prueba.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, 350, 300, 400, 150],
        'Discount': [10, 15, 20, 5, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Create target variable (high value if PurchaseAmount > 300)
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)

# Step 2: Define features and target
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 4: Build and train a Random Forest model
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)

# Step 5: Predict and evaluate accuracy on the test set
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Model Accuracy: {accuracy:.2f}")

Ejercicio 5: Uso de Pipelines de Scikit-learn para Flujos de Trabajo Eficientes

Tu tarea es crear un flujo de trabajo eficiente para los datos de transacciones de clientes. Tus tareas son:

Crear un pipeline de Scikit-learn que impute los valores faltantes, escale las características y entrene un modelo de Random Forest.
Entrenar el pipeline con el conjunto de datos y evaluar el desempeño del modelo.

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Define features and target
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 2: Create the pipeline
pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),  # Impute missing values
    ('scaler', StandardScaler()),  # Scale features
    ('classifier', RandomForestClassifier(random_state=42))  # Train Random Forest model
])

# Step 3: Train the pipeline
pipeline.fit(X_train, y_train)

# Step 4: Make predictions and evaluate the model
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Pipeline Model Accuracy: {accuracy:.2f}")

2.4 Ejercicios Prácticos para el Capítulo 2: Optimización de Flujos de Trabajo de Datos

Ejercicio 1: Manipulación Avanzada de Datos con Pandas

Tienes un conjunto de datos de pedidos en línea de una tienda de comercio electrónico. Tu tarea es:

Filtrar el conjunto de datos para incluir solo pedidos donde el monto del pedido es mayor a $200.
Agrupar el conjunto de datos por Categoría y CustomerID para calcular los montos totales y promedios de pedido para cada grupo.
Crear una tabla dinámica de modo que cada Categoría sea una columna y las filas representen cada CustomerID.

import pandas as pd

# Sample data: Online orders
data = {'OrderID': [1, 2, 3, 4, 5],
        'CustomerID': [101, 102, 103, 101, 104],
        'Category': ['Electronics', 'Clothing', 'Electronics', 'Furniture', 'Furniture'],
        'OrderAmount': [250, 120, 300, 400, 500]}

df = pd.DataFrame(data)

# Solution
# Step 1: Filter orders where OrderAmount > 200
filtered_df = df[df['OrderAmount'] > 200]

# Step 2: Group by Category and CustomerID, and calculate total and average order amounts
grouped_df = filtered_df.groupby(['Category', 'CustomerID']).agg(
    TotalAmount=('OrderAmount', 'sum'),
    AvgAmount=('OrderAmount', 'mean')
).reset_index()

# Step 3: Pivot the dataset so that Category is a column
pivot_df = grouped_df.pivot(index='CustomerID', columns='Category', values='TotalAmount').fillna(0)

print(pivot_df)

Ejercicio 2: Mejorando el Rendimiento con NumPy

Dado un arreglo de precios de productos, tu tarea es:

Aplicar una transformación logarítmica para normalizar los precios.
Usar broadcasting para aplicar un descuento del 20% a cada precio.
Calcular el precio promedio con descuento usando las funciones vectorizadas de NumPy.

import numpy as np

# Sample data: Product prices
prices = np.array([100, 150, 200, 250, 300])

# Solution
# Step 1: Apply a logarithmic transformation
log_prices = np.log(prices)

# Step 2: Apply a 20% discount using broadcasting
discounted_prices = prices * 0.80

# Step 3: Calculate the average discounted price
average_discounted_price = np.mean(discounted_prices)

print("Logarithmic Prices:", log_prices)
print("Discounted Prices:", discounted_prices)
print("Average Discounted Price:", average_discounted_price)

Ejercicio 3: Combinando Pandas y NumPy para Ingeniería de Características

Tienes un conjunto de datos de transacciones de clientes, que incluye el monto de compra y el descuento recibido. Tu tarea es:

Llenar los valores faltantes en las columnas PurchaseAmount y Discount con la media de cada columna.
Crear una nueva característica, NetPurchase, que sea el monto de la compra después de aplicar el descuento.
Usar NumPy para crear una característica de interacción multiplicando las columnas PurchaseAmount y Discount.

import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Fill missing values
df['PurchaseAmount'].fillna(df['PurchaseAmount'].mean(), inplace=True)
df['Discount'].fillna(df['Discount'].mean(), inplace=True)

# Step 2: Create NetPurchase feature
df['NetPurchase'] = df['PurchaseAmount'] - df['Discount']

# Step 3: Create an interaction feature using NumPy
df['Interaction_Purchase_Discount'] = df['PurchaseAmount'] * df['Discount']

print(df)

Ejercicio 4: Construcción de un Modelo de Clasificación con Scikit-learn

Tienes un conjunto de datos de transacciones de clientes. Tu tarea es:

Crear una variable objetivo que marque las compras mayores a $300 como alto valor.
Usar Scikit-learn para dividir los datos en conjuntos de entrenamiento y prueba.
Construir un modelo de clasificación con Random Forest para predecir compras de alto valor.
Evaluar el modelo calculando la precisión en el conjunto de prueba.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, 350, 300, 400, 150],
        'Discount': [10, 15, 20, 5, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Create target variable (high value if PurchaseAmount > 300)
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)

# Step 2: Define features and target
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 4: Build and train a Random Forest model
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)

# Step 5: Predict and evaluate accuracy on the test set
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Model Accuracy: {accuracy:.2f}")

Ejercicio 5: Uso de Pipelines de Scikit-learn para Flujos de Trabajo Eficientes

Tu tarea es crear un flujo de trabajo eficiente para los datos de transacciones de clientes. Tus tareas son:

Crear un pipeline de Scikit-learn que impute los valores faltantes, escale las características y entrene un modelo de Random Forest.
Entrenar el pipeline con el conjunto de datos y evaluar el desempeño del modelo.

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np

# Sample data: Customer transactions
data = {'CustomerID': [1, 2, 3, 4, 5],
        'PurchaseAmount': [250, np.nan, 300, 400, np.nan],
        'Discount': [10, 15, 20, np.nan, 5]}

df = pd.DataFrame(data)

# Solution
# Step 1: Define features and target
df['HighValue'] = (df['PurchaseAmount'] > 300).astype(int)
X = df[['PurchaseAmount', 'Discount']]
y = df['HighValue']

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

# Step 2: Create the pipeline
pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),  # Impute missing values
    ('scaler', StandardScaler()),  # Scale features
    ('classifier', RandomForestClassifier(random_state=42))  # Train Random Forest model
])

# Step 3: Train the pipeline
pipeline.fit(X_train, y_train)

# Step 4: Make predictions and evaluate the model
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Pipeline Model Accuracy: {accuracy:.2f}")

Compra este libro