Guía Completa para el Preprocesamiento de Datos y Construcción de Modelos para el Aprendizaje Automático
Tabla de Contenidos
- Introducción
- Importación y Exploración de Datos
- Manejo de Datos Faltantes
- Codificación de Variables Categóricas
- Selección de Características
- División de Entrenamiento y Prueba
- Escalado de Características
- Construcción de Modelos de Regresión
- Evaluación del Modelo
- Conclusión
1. Introducción
El preprocesamiento de datos es una fase crítica en la cadena de aprendizaje automático. Implica transformar los datos en bruto en un formato que sea adecuado para el modelado, mejorando así el rendimiento y la precisión de los modelos predictivos. Este artículo ilustra el proceso paso a paso de preprocesamiento de datos y construcción de modelos utilizando un conjunto de datos meteorológicos obtenido de Kaggle.
2. Importación y Exploración de Datos
Antes de sumergirse en el preprocesamiento, es esencial cargar y comprender el conjunto de datos.
|
1 2 3 4 5 6 7 8 |
import pandas as pd import seaborn as sns # Load the dataset data = pd.read_csv('weatherAUS.csv') # Display the last five rows print(data.tail()) |
Salida de Muestra:
|
1 2 |
Date Location MinTemp MaxTemp Rainfall Evaporation Sunshine WindGustDir WindGustSpeed WindDir9am ... Humidity3pm Pressure9am Pressure3pm Cloud9am Cloud3pm Temp9am Temp3pm RainToday RISK_MM RainTomorrow 142188 2017-06-20 Uluru 3.5 21.8 0.0 NaN NaN E 31.0 ESE ... 27.0 1024.7 1021.2 NaN NaN 9.4 20.9 No 0.0 No |
Comprender la estructura del conjunto de datos es crucial para un preprocesamiento efectivo. Utilice .info() y .describe() para obtener información sobre los tipos de datos y resúmenes estadísticos.
3. Manejo de Datos Faltantes
Los datos faltantes pueden distorsionar los resultados de su análisis. Es vital manejarlos adecuadamente.
Datos Numéricos
Para columnas numéricas, los valores faltantes pueden imputarse utilizando estrategias como la media, la mediana o la moda.
|
1 2 3 4 5 6 7 8 9 10 11 |
import numpy as np from sklearn.impute import SimpleImputer # Identify numerical columns numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0]) # Initialize the imputer with a mean strategy imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') # Fit and transform the data X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols]) |
Datos Categóricos
Para columnas categóricas, los valores faltantes pueden imputarse utilizando el valor más frecuente.
|
1 2 3 4 5 6 7 8 |
# Identify string columns string_cols = list(np.where((X.dtypes == object))[0]) # Initialize the imputer with the most frequent strategy imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent') # Fit and transform the data X.iloc[:, string_cols] = imp_freq.fit_transform(X.iloc[:, string_cols]) |
4. Codificación de Variables Categóricas
Los modelos de aprendizaje automático requieren entradas numéricas. Por lo tanto, las variables categóricas necesitan ser codificadas apropiadamente.
Codificación de Etiquetas
La Codificación de Etiquetas transforma las etiquetas categóricas en valores numéricos. Es adecuada para categorías binarias o datos ordinales.
|
1 2 3 4 5 |
from sklearn import preprocessing def LabelEncoderMethod(series): le = preprocessing.LabelEncoder() return le.fit_transform(series) |
Codificación One-Hot
La Codificación One-Hot convierte variables categóricas en una matriz binaria. Es ideal para datos nominales con más de dos categorías.
|
1 2 3 4 5 6 |
from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder def OneHotEncoderMethod(indices, data): columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough') return columnTransformer.fit_transform(data) |
Selección de Codificación Basada en Umbral
Para agilizar el proceso de codificación, puede crear una función que seleccione el método de codificación basado en el número de categorías en cada columna.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
def EncodingSelection(X, threshold=10): # Select string columns string_cols = list(np.where((X.dtypes == object))[0]) one_hot_encoding_indices = [] # Decide on encoding based on the number of unique categories for col in string_cols: length = len(pd.unique(X[X.columns[col]])) if length == 2 or length > threshold: X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]]) else: one_hot_encoding_indices.append(col) # Apply One-Hot Encoding to selected columns X = OneHotEncoderMethod(one_hot_encoding_indices, X) return X # Apply encoding selection X = EncodingSelection(X) |
5. Selección de Características
La selección de características implica elegir las características más relevantes para la construcción del modelo. Se pueden emplear técnicas como el análisis de correlación, mapas de calor y métodos como SelectKBest para identificar características impactantes.
6. División de Entrenamiento y Prueba
Dividir el conjunto de datos en conjuntos de entrenamiento y prueba es esencial para evaluar el rendimiento del modelo en datos no vistos.
|
1 2 3 4 5 6 7 |
from sklearn.model_selection import train_test_split # Split the data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1) print(X_train.shape) # Output: (164, 199) |
7. Escalado de Características
El escalado de características asegura que todas las características contribuyan por igual al resultado. Ayuda a acelerar la convergencia del descenso de gradiente.
Estandarización
La estandarización transforma los datos para que tengan una media de cero y una desviación estándar de uno.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn import preprocessing sc = preprocessing.StandardScaler(with_mean=False) sc.fit(X_train) X_train = sc.transform(X_train) X_test = sc.transform(X_test) print(X_train.shape) # Output: (164, 199) |
Normalización
La normalización escala los datos a un rango fijo, típicamente entre 0 y 1.
|
1 2 3 4 5 |
from sklearn.preprocessing import MinMaxScaler min_max_scaler = MinMaxScaler() X_train = min_max_scaler.fit_transform(X_train) X_test = min_max_scaler.transform(X_test) |
8. Construcción de Modelos de Regresión
Una vez que los datos están preprocesados, se pueden construir y evaluar varios modelos de regresión. A continuación se presentan implementaciones de varios algoritmos de regresión populares.
Regresión Lineal
Un algoritmo fundamental que modela la relación entre la variable dependiente y una o más variables independientes.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sklearn.linear_model import LinearRegression from sklearn.metrics import r2_score # Initialize and train the model model = LinearRegression() model.fit(X_train, y_train) # Predict and evaluate y_pred = model.predict(X_test) score = r2_score(y_test, y_pred) print(f"Linear Regression R2 Score: {score}") # Output: 0.09741670577134398 |
Regresión Polinómica
Mejora el modelo lineal al agregar términos polinómicos, capturando relaciones no lineales.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from sklearn.linear_model import LinearRegression from sklearn.preprocessing import PolynomialFeatures # Initialize polynomial features and linear regression poly = PolynomialFeatures(degree=2) X_train_poly = poly.fit_transform(X_train) model = LinearRegression() # Train and predict model.fit(X_train_poly, y_train) X_test_poly = poly.transform(X_test) y_pred = model.predict(X_test_poly) score = r2_score(y_test, y_pred) print(f"Polynomial Regression R2 Score: {score}") # Output: -0.4531422286977287 |
Nota: Un puntaje R² negativo indica un rendimiento deficiente del modelo.
Regresor de Árbol de Decisión
Un modelo no lineal que divide los datos en subconjuntos basados en los valores de las características.
|
1 2 3 4 5 6 7 8 9 10 11 |
from sklearn.tree import DecisionTreeRegressor # Initialize and train the model model = DecisionTreeRegressor(max_depth=4) model.fit(X_train, y_train) # Predict and evaluate y_pred = model.predict(X_test) score = r2_score(y_test, y_pred) print(f"Decision Tree Regressor R2 Score: {score}") # Output: 0.883961900453219 |
Regresor de Bosque Aleatorio
Un método de conjunto que combina múltiples árboles de decisión para mejorar el rendimiento y reducir el sobreajuste.
|
1 2 3 4 5 6 7 8 9 10 11 |
from sklearn.ensemble import RandomForestRegressor # Initialize and train the model model = RandomForestRegressor(n_estimators=25, random_state=10) model.fit(X_train, y_train) # Predict and evaluate y_pred = model.predict(X_test) score = r2_score(y_test, y_pred) print(f"Random Forest Regressor R2 Score: {score}") # Output: 0.9107611439295349 |
Regresor AdaBoost
Otra técnica de conjunto que combina aprendices débiles para formar un predictor fuerte.
|
1 2 3 4 5 6 7 8 9 10 11 |
from sklearn.ensemble import AdaBoostRegressor # Initialize and train the model model = AdaBoostRegressor(random_state=0, n_estimators=100) model.fit(X_train, y_train) # Predict and evaluate y_pred = model.predict(X_test) score = r2_score(y_test, y_pred) print(f"AdaBoost Regressor R2 Score: {score}") # Output: 0.8806696893560713 |
Regresor XGBoost
Un potente marco de boosting de gradiente optimizado para velocidad y rendimiento.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import xgboost as xgb # Initialize and train the model model = xgb.XGBRegressor( n_estimators=100, reg_lambda=1, gamma=0, max_depth=3, learning_rate=0.05 ) model.fit(X_train, y_train) # Predict and evaluate y_pred = model.predict(X_test) score = r2_score(y_test, y_pred) print(f"XGBoost Regressor R2 Score: {score}") # Output: 0.8947431439987505 |
Regresor de Máquina de Vectores de Soporte (SVM)
SVM puede adaptarse para tareas de regresión, capturando relaciones complejas.
|
1 2 3 4 5 6 7 8 9 10 11 |
from sklearn.svm import SVR # Initialize and train the model model = SVR() model.fit(X_train, y_train) # Predict and evaluate y_pred = model.predict(X_test) score = r2_score(y_test, y_pred) print(f"SVM Regressor R2 Score: {score}") # Output: -0.02713944090388254 |
Nota: El puntaje R² negativo significa que el modelo funciona peor que una línea horizontal.
9. Evaluación del Modelo
El puntaje R² es una métrica común para evaluar modelos de regresión. Indica la proporción de la varianza en la variable dependiente predecible a partir de las variables independientes.
- R² Positivo: El modelo explica una porción de la varianza.
- R² Negativo: El modelo no logra explicar la varianza, funcionando peor que un modelo ingenuo basado en la media.
En esta guía, el Regresor de Bosque Aleatorio logró el puntaje R² más alto de aproximadamente 0.91, indicando un fuerte rendimiento en los datos de prueba.
10. Conclusión
Un preprocesamiento efectivo de datos sienta las bases para construir modelos de aprendizaje automático robustos. Al manejar meticulosamente los datos faltantes, seleccionar técnicas de codificación apropiadas y escalar las características, mejora la calidad de sus datos, lo que conduce a un mejor rendimiento del modelo. Entre los modelos de regresión explorados, los métodos de conjunto como Bosque Aleatorio y AdaBoost demostraron capacidades predictivas superiores en el conjunto de datos meteorológicos. Siempre recuerde evaluar sus modelos a fondo y elegir el que mejor se alinee con los objetivos de su proyecto.
Adopte estas estrategias de preprocesamiento y modelado para desbloquear todo el potencial de sus conjuntos de datos y generar soluciones de aprendizaje automático impactantes.