S24L01 – Árbol de decisión y Bosque aleatorio

html
Implementación de Árboles de Decisión, Random Forests, XGBoost y AdaBoost para la Predicción del Clima en Python

Tabla de Contenidos

    Introducción
    Descripción del Conjunto de Datos
    Preprocesamiento de Datos
        
            Manejo de Valores Faltantes
            Codificación de Variables Categóricas
            Selección de Características
            División de Entrenamiento y Prueba y Escalado de Características
        
    
    Implementación y Evaluación de Modelos
        
            K-Nearest Neighbors (KNN)
            Regresión Logística
            Gaussian Naive Bayes
            Máquina de Vectores de Soporte (SVM)
            Árbol de Decisión
            Random Forest
            XGBoost y AdaBoost
        
    
    Visualización de Regiones de Decisión
    Conclusión
    Referencias


Introducción
Predecir las condiciones climáticas es un problema clásico en el aprendizaje automático, ofreciendo valiosas ideas para diversas industrias como la agricultura, la aviación y la planificación de eventos. En esta guía completa, nos adentraremos en la implementación de varios modelos de aprendizaje automático, incluyendo Árboles de Decisión, Random Forests, XGBoost y AdaBoost, para predecir si lloverá mañana utilizando el conjunto de datos Weather Australia. Recorreremos el preprocesamiento de datos, el entrenamiento del modelo, la evaluación e incluso la implementación de estos modelos en aplicaciones web de la vida real.

Descripción del Conjunto de Datos
El conjunto de datos Weather Australia, obtenido de Kaggle, contiene 24 características relacionadas con las condiciones climáticas registradas en diversas ubicaciones de Australia. El objetivo principal es predecir el atributo RainTomorrow, que indica si lloverá al día siguiente.

Características del Conjunto de Datos

    Date: Fecha de la observación.
    Location: Ubicación geográfica de la estación meteorológica.
    MinTemp: Temperatura mínima en °C.
    MaxTemp: Temperatura máxima en °C.
    Rainfall: Cantidad de lluvia en mm.
    Evaporation: Evaporación en mm.
    Sunshine: Número de horas de sol.
    WindGustDir: Dirección de la ráfaga de viento más fuerte.
    WindGustSpeed: Velocidad de la ráfaga de viento más fuerte en km/h.
    WindDir9am: Dirección del viento a las 9 AM.
    WindDir3pm: Dirección del viento a las 3 PM.
    ...y más.


Preprocesamiento de Datos
El preprocesamiento efectivo de datos es crucial para construir modelos de aprendizaje automático precisos y fiables. Abordaremos el manejo de valores faltantes, la codificación de variables categóricas, la selección de características y el escalado.

Manejo de Valores Faltantes
Los datos faltantes pueden impactar significativamente el rendimiento del modelo. Abordaremos los valores faltantes por separado para datos numéricos y categóricos.

Datos Numéricos
Para las columnas numéricas, utilizaremos Imputación por Media para rellenar los valores faltantes.





		
		
			
			
Java
			
			import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer

# Load data
data = pd.read_csv('weatherAUS.csv')

# Identify numerical columns
numerical_cols = data.select_dtypes(include=['int64', 'float64']).columns

# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
data[numerical_cols] = imp_mean.fit_transform(data[numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer
 
# Load data
data = pd.read_csv('weatherAUS.csv')
 
# Identify numerical columns
numerical_cols = data.select_dtypes(include=['int64', 'float64']).columns
 
# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
data[numerical_cols] = imp_mean.fit_transform(data[numerical_cols])
					
				
			
		



Datos Categóricos
Para las columnas categóricas, utilizaremos Imputación por Valor Más Frecuente.





		
		
			
			
Java
			
			# Identify categorical columns
categorical_cols = data.select_dtypes(include=['object']).columns

# Impute missing values with the most frequent value
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
data[categorical_cols] = imp_freq.fit_transform(data[categorical_cols])
			
				
					
				
					1
2
3
4
5
6
				
						# Identify categorical columns
categorical_cols = data.select_dtypes(include=['object']).columns
 
# Impute missing values with the most frequent value
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
data[categorical_cols] = imp_freq.fit_transform(data[categorical_cols])
					
				
			
		



Codificación de Variables Categóricas
Los algoritmos de aprendizaje automático requieren entradas numéricas. Emplearemos tanto Codificación de Etiquetas (Label Encoding) como Codificación One-Hot (One-Hot Encoding) según el número de categorías únicas en cada característica.





		
		
			
			
Java
			
			from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

def encode_features(df, threshold=10):
    label_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() <= threshold]
    onehot_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() > threshold]
    
    # Label Encoding
    le = LabelEncoder()
    for col in label_enc_cols:
        df[col] = le.fit_transform(df[col])
    
    # One-Hot Encoding
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), onehot_enc_cols)], remainder='passthrough')
    df = ct.fit_transform(df)
    
    return df

X = data.drop('RainTomorrow', axis=1)
y = data['RainTomorrow']

X = encode_features(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer
 
def encode_features(df, threshold=10):
    label_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() <= threshold]
    onehot_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() > threshold]
    
    # Label Encoding
    le = LabelEncoder()
    for col in label_enc_cols:
        df[col] = le.fit_transform(df[col])
    
    # One-Hot Encoding
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), onehot_enc_cols)], remainder='passthrough')
    df = ct.fit_transform(df)
    
    return df
 
X = data.drop('RainTomorrow', axis=1)
y = data['RainTomorrow']
 
X = encode_features(X)
					
				
			
		



Selección de Características
Para mejorar el rendimiento del modelo y reducir la complejidad computacional, seleccionaremos las características principales utilizando el método SelectKBest con la estadística Chi-Cuadrado.





		
		
			
			
Java
			
			from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Select top 10 features
selector = SelectKBest(score_func=chi2, k=10)
X_selected = selector.fit_transform(X_scaled, y)

# Further reduce to top 2 features for visualization
best_features = selector.get_support(indices=True)
X_final = X_selected[:, :2]
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
 
# Select top 10 features
selector = SelectKBest(score_func=chi2, k=10)
X_selected = selector.fit_transform(X_scaled, y)
 
# Further reduce to top 2 features for visualization
best_features = selector.get_support(indices=True)
X_final = X_selected[:, :2]
					
				
			
		



División de Entrenamiento y Prueba y Escalado de Características
Dividir los datos en conjuntos de entrenamiento y prueba asegura que el rendimiento de nuestro modelo sea evaluado en datos no vistos.





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X_final, y, test_size=0.20, random_state=1)

# Feature Scaling
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
 
# Split the data
X_train, X_test, y_train, y_test = train_test_split(X_final, y, test_size=0.20, random_state=1)
 
# Feature Scaling
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		



Implementación y Evaluación de Modelos
Implementaremos varios modelos de aprendizaje automático y evaluaremos su rendimiento utilizando la Puntuación de Precisión (Accuracy Score).

K-Nearest Neighbors (KNN)





		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {knn_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {knn_accuracy:.2f}')
					
				
			
		


Precisión de KNN: 0.80

Regresión Logística





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {lr_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.linear_model import LogisticRegression
 
log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {lr_accuracy:.2f}')
					
				
			
		


Precisión de Regresión Logística: 0.83

Gaussian Naive Bayes





		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
gnb_accuracy = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {gnb_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.naive_bayes import GaussianNB
 
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
gnb_accuracy = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {gnb_accuracy:.2f}')
					
				
			
		


Precisión de Gaussian Naive Bayes: 0.80

Máquina de Vectores de Soporte (SVM)





		
		
			
			
Java
			
			from sklearn.svm import SVC

svm = SVC()
svm.fit(X_train, y_train)
y_pred_svm = svm.predict(X_test)
svm_accuracy = accuracy_score(y_pred_svm, y_test)
print(f'SVM Accuracy: {svm_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.svm import SVC
 
svm = SVC()
svm.fit(X_train, y_train)
y_pred_svm = svm.predict(X_test)
svm_accuracy = accuracy_score(y_pred_svm, y_test)
print(f'SVM Accuracy: {svm_accuracy:.2f}')
					
				
			
		


Precisión de SVM: 0.83

Árbol de Decisión





		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeClassifier

dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)
y_pred_dtc = dtc.predict(X_test)
dtc_accuracy = accuracy_score(y_pred_dtc, y_test)
print(f'Decision Tree Accuracy: {dtc_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.tree import DecisionTreeClassifier
 
dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)
y_pred_dtc = dtc.predict(X_test)
dtc_accuracy = accuracy_score(y_pred_dtc, y_test)
print(f'Decision Tree Accuracy: {dtc_accuracy:.2f}')
					
				
			
		


Precisión de Árbol de Decisión: 0.83

Random Forest





		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=500, max_depth=5)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
rf_accuracy = accuracy_score(y_pred_rf, y_test)
print(f'Random Forest Accuracy: {rf_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.ensemble import RandomForestClassifier
 
rf = RandomForestClassifier(n_estimators=500, max_depth=5)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
rf_accuracy = accuracy_score(y_pred_rf, y_test)
print(f'Random Forest Accuracy: {rf_accuracy:.2f}')
					
				
			
		


Precisión de Random Forest: 0.83

XGBoost y AdaBoost
Aunque la implementación inicial no cubre XGBoost y AdaBoost, estos métodos de ensamblado pueden mejorar aún más el rendimiento del modelo. Aquí hay un breve ejemplo de cómo implementarlos:

XGBoost





		
		
			
			
Java
			
			from xgboost import XGBClassifier

xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
xgb.fit(X_train, y_train)
y_pred_xgb = xgb.predict(X_test)
xgb_accuracy = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {xgb_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from xgboost import XGBClassifier
 
xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
xgb.fit(X_train, y_train)
y_pred_xgb = xgb.predict(X_test)
xgb_accuracy = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {xgb_accuracy:.2f}')
					
				
			
		



AdaBoost





		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostClassifier

ada = AdaBoostClassifier(n_estimators=100, random_state=0)
ada.fit(X_train, y_train)
y_pred_ada = ada.predict(X_test)
ada_accuracy = accuracy_score(y_pred_ada, y_test)
print(f'AdaBoost Accuracy: {ada_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.ensemble import AdaBoostClassifier
 
ada = AdaBoostClassifier(n_estimators=100, random_state=0)
ada.fit(X_train, y_train)
y_pred_ada = ada.predict(X_test)
ada_accuracy = accuracy_score(y_pred_ada, y_test)
print(f'AdaBoost Accuracy: {ada_accuracy:.2f}')
					
				
			
		



Nota: Asegúrate de tener instalada la biblioteca xgboost usando pip install xgboost.

Visualización de Regiones de Decisión
Visualizar los límites de decisión ayuda a comprender cómo diferentes modelos clasifican los datos. A continuación, se muestra un ejemplo utilizando el conjunto de datos Iris:





		
		
			
			
Java
			
			from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets

# Load Iris dataset
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target

# Train KNN
knn_vis = KNeighborsClassifier(n_neighbors=3)
knn_vis.fit(X_vis, y_vis)

# Plot decision regions
plot_decision_regions(X_vis, y_vis, clf=knn_vis)

plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('KNN Decision Regions')
plt.legend()
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
 
# Load Iris dataset
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target
 
# Train KNN
knn_vis = KNeighborsClassifier(n_neighbors=3)
knn_vis.fit(X_vis, y_vis)
 
# Plot decision regions
plot_decision_regions(X_vis, y_vis, clf=knn_vis)
 
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('KNN Decision Regions')
plt.legend()
plt.show()
					
				
			
		



Salida de la Visualización: Un gráfico que muestra los límites de decisión creados por el clasificador KNN.

Conclusión
En esta guía, hemos explorado la implementación de varios modelos de aprendizaje automático—Árboles de Decisión, Random Forests, Regresión Logística, KNN, Gaussian Naive Bayes y SVM—para predecir condiciones climáticas utilizando el conjunto de datos Weather Australia. Cada modelo mostró puntuaciones de precisión competitivas, con Regresión Logística, SVM, Árboles de Decisión y Random Forests alcanzando aproximadamente un 83% de precisión.
Para mejorar el rendimiento, se pueden integrar métodos de ensamblado como XGBoost y AdaBoost. Además, implementar estos modelos en aplicaciones web puede proporcionar predicciones climáticas en tiempo real, haciendo que las ideas sean accionables para los usuarios finales.

Referencias

    Conjunto de Datos Weather Australia en Kaggle
    Documentación de Scikit-Learn
    Documentación de XGBoost
    MLxtend: Extensiones de Aprendizaje Automático
    Documentación de Pandas