Modelos de aprendizaje automático de Sklearn

Los modelos de aprendizaje automático son herramientas fundamentales para realizar análisis de datos automatizado, reconocimiento de patrones y predicción.

Según el tipo de tarea, los modelos de aprendizaje automático generalmente se pueden clasificar en:

  • Modelos de clasificación (Classification):Predicen categorías discretas.
  • Modelos de regresión (Regression):Predicen valores numéricos continuos.
  • Modelos de clustering (Clustering):Agrupan datos automáticamente.

Este capítulo presentará en detalle estos modelos de aprendizaje automático comunes y explicará cómo evaluar y optimizar los modelos.

1、Modelos de clasificación

La clasificación es uno de los problemas más comunes en el aprendizaje automático; su objetivo es mapear los datos de entrada a etiquetas de clase discretas.

Los modelos de clasificación comunes incluyen:

  • Regresión logística
  • K-vecinos (KNN)
  • Máquina de vectores de soporte (SVM)
  • Árbol de decisión
  • Bosque aleatorio

Regresión logística (Logistic Regression)

Aunque la regresión logística lleva "regresión" en su nombre, en esencia es unmodelo de clasificación probabilístico, y se usa comúnmente para problemas de clasificación binaria.

Su idea principal es:

  • Primero realizar una suma ponderada lineal
  • y luego mapear el resultado a un valor entre 0 y 1 como probabilidad mediante la función Sigmoid.

Se puede expresar como:

La fórmula central de la regresión logística es:

Implementación en scikit-learn:

Ejemplo

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Supongamos que X es la matriz de características e y es la etiqueta
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = LogisticRegression()
model.fit(X_train, y_train)

# Predicción
y_pred = model.predict(X_test)

K-vecinos (K-Nearest Neighbors, KNN)

K-vecinos (KNN) es un método de aprendizaje basado en instancias. Para predecir, calcula la distancia entre la muestra a predecir y todas las muestras del conjunto de entrenamiento, selecciona los K vecinos más cercanos y realiza la predicción según las etiquetas de dichos vecinos.

Parámetros principales:

  • K: número de vecinos seleccionados.
  • Medida de distancia: comúnmente se usa la distancia euclidiana; también se pueden usar la distancia de Manhattan, la distancia de Minkowski, etc.

Implementación en scikit-learn:

Ejemplo

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

# Supongamos que X es la matriz de características e y es la etiqueta
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_train, y_train)

# Predicción
y_pred = model.predict(X_test)

Máquina de vectores de soporte (Support Vector Machine, SVM)

La máquina de vectores de soporte es un potente modelo de clasificación, especialmente adecuado para datos de alta dimensión.

La idea básica de SVM es encontrar un hiperplano que maximice el margen entre los puntos de muestra de diferentes clases. Para datos no linealmente separables, SVM utiliza el truco del núcleo (kernel) para mapear los datos a un espacio de alta dimensión y encontrar un hiperplano de separación.

Funciones de núcleo (kernel):

  • Núcleo lineal: adecuado para datos linealmente separables.
  • Núcleo gaussiano de base radial (RBF): adecuado para datos no lineales.
  • Núcleo polinómico: adecuado para datos con relaciones polinómicas.

Implementación en scikit-learn:

Ejemplo

from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

# Supongamos que X es la matriz de características e y es la etiqueta
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = SVC(kernel='linear')  # Usar núcleo lineal
model.fit(X_train, y_train)

# Predicción
y_pred = model.predict(X_test)

Árbol de decisión y bosque aleatorio (Decision Tree & Random Forest)

El árbol de decisión es un modelo de clasificación con estructura de árbol que divide los datos mediante particiones sucesivas hasta asignarlos a diferentes categorías. El bosque aleatorio, por su parte, construye múltiples árboles de decisión y determina la predicción final mediante votación o promedio.

Árbol de decisiónRealiza la partición de los datos seleccionando las mejores características; los criterios de selección suelen serganancia de informaciónocoeficiente de Gini。

Bosque aleatorioMediante la integración de múltiples árboles de decisión reduce el sobreajuste y mejora la precisión del modelo. Introduce aleatoriedad (como selección aleatoria de características y subconjuntos de datos) para aumentar la diversidad del modelo.

Implementación en scikit-learn:

Ejemplo

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Supongamos que X es la matriz de características e y es la etiqueta
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Árbol de decisión
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)

# Bosque aleatorio
rf_model = RandomForestClassifier(n_estimators=100)
rf_model.fit(X_train, y_train)

# Predicción
dt_pred = dt_model.predict(X_test)
rf_pred = rf_model.predict(X_test)

2、Modelos de regresión

El objetivo de un problema de regresión es predecir una variable de salida continua. Los modelos de regresión comunes incluyen regresión lineal, regresión Ridge y regresión Lasso.

Regresión lineal (Linear Regression)

La regresión lineal predice la variable objetivo ajustando una línea recta. Su supuesto fundamental es que existe una relación lineal entre las características y la variable objetivo.

Para un problema de regresión lineal simple, el modelo se puede expresar como:

  • y es el valor predicho (variable objetivo).
  • x1，x2，xnes la característica de entrada.
  • w1，w2，wnson los pesos a aprender (parámetros del modelo).
  • b es el término de sesgo.

Implementación en scikit-learn:

Ejemplo

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Supongamos que X es la matriz de características e y es la variable objetivo
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = LinearRegression()
model.fit(X_train, y_train)

# Predicción
y_pred = model.predict(X_test)

Regresión Ridge (Ridge Regression)

La regresión Ridge es una variante de la regresión lineal que utilizaregularización L2para restringir la complejidad del modelo y evitar el sobreajuste. Al penalizar la magnitud de los coeficientes de regresión, la regresión Ridge maneja mejor los problemas de multicolinealidad.

Implementación en scikit-learn:

Ejemplo

from sklearn.linear_model import Ridge

model = Ridge(alpha=1.0)  # alpha es el parámetro de regularización
model.fit(X_train, y_train)

# Predicción
y_pred = model.predict(X_test)

Regresión Lasso (Lasso Regression)

La regresión Lasso también es una forma de regresión lineal que utilizaregularización L1para penalizar los coeficientes de regresión. A diferencia de la regresión Ridge, Lasso reduce algunos coeficientes a cero, logrando así selección de características.

Implementación en scikit-learn:

Ejemplo

from sklearn.linear_model import Lasso

model = Lasso(alpha=0.1)  # alpha es el parámetro de regularización
model.fit(X_train, y_train)

# Predicción
y_pred = model.predict(X_test)

3、Modelos de clustering

El clustering es un método de aprendizaje no supervisado cuyo objetivo es dividir los objetos de un conjunto de datos en diferentes grupos (o clústeres), de modo que los objetos dentro del mismo clúster sean lo más similares posible y los de diferentes clústeres sean lo más distintos posible.

K-medias (K-Means)

K-medias es un algoritmo de clustering común cuyo objetivo es dividir los datos en K clústeres, optimizando la partición al minimizar la distancia entre cada punto de datos y el centro de su clúster.

Implementación en scikit-learn:

Ejemplo

from sklearn.cluster import KMeans

# Supongamos que X es la matriz de características
model = KMeans(n_clusters=3)
model.fit(X)

# Obtener las etiquetas de los clústeres
labels = model.predict(X)

DBSCAN (clustering por densidad)

DBSCAN (Density-Based Spatial Clustering of Applications with Noise) es un algoritmo de clustering basado en densidad que agrupa los datos buscando regiones de densidad relativamente alta, sin necesidad de especificar el número de clústeres de antemano.

Implementación en scikit-learn:

Ejemplo

from sklearn.cluster import DBSCAN

# Supongamos que X es la matriz de características
model = DBSCAN(eps=0.5, min_samples=5)
model.fit(X)

# Obtener etiquetas de clúster
labels = model.labels_

Clustering jerárquico (Hierarchical Clustering)

El agrupamiento jerárquico es un método de agrupamiento que agrupa mediante la fusión o división recursiva de clústeres. Los métodos de agrupamiento jerárquico más comunes son:Agrupamiento aglomerativo(Agglomerative) yAgrupamiento divisivo（Divisive）。

Implementación con scikit-learn:

Ejemplo

from sklearn.cluster import AgglomerativeClustering

# Supongamos que X es la matriz de características
model = AgglomerativeClustering(n_clusters=3)
labels = model.fit_predict(X)

4、Evaluación y selección de modelos

En el aprendizaje automático, una vez completado el entrenamiento del modelo, es necesario evaluar la capacidad de generalización del modelo mediante métodos de evaluación razonables y seleccionar el modelo con mejor rendimiento.

Los métodos de evaluación comunes incluyen:

  • Evaluación con métricas de clasificación
  • Validación cruzada
  • Ajuste de hiperparámetros

Métricas de evaluación de clasificación

En problemas de clasificación, las métricas de evaluación más utilizadas incluyen:

  • Exactitud (Accuracy)
  • Precisión (Precision)
  • Exhaustividad (Recall)
  • Puntuación F1 (F1 Score)

Reflejan el rendimiento del modelo desde diferentes perspectivas.

Explicación del significado de cada métrica:

  • Exactitud (Accuracy)-- Proporción de predicciones correctas entre todas las muestras: adecuada para casos con una distribución de clases relativamente equilibrada.

  • Precisión (Precision)-- Proporción de muestras realmente positivas entre las predichas como positivas: se centra en "si la predicción positiva es confiable".

  • Exhaustividad (Recall)-- Proporción de muestras realmente positivas que el modelo identifica correctamente: se centra en "si se pasan por alto muestras positivas".

Puntuación F1

Media armónica de Precision y Recall:

Se utiliza para lograr un equilibrio entre precisión y recall.

Implementación con scikit-learn:

Ejemplo

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

print(f"Accuracy: {accuracy}")
print(f"Precision: {precision}")
print(f"Recall: {recall}")
print(f"F1 Score: {f1}")

Evaluación por método holdout (división en conjunto de entrenamiento / prueba)

La forma más común e intuitiva de evaluar es dividir el conjunto de datos en:

  • Conjunto de entrenamiento: para que el modelo aprenda
  • Conjunto de prueba: para evaluar el rendimiento

Este método es simple y eficiente, adecuado para comprender el efecto del modelo en la etapa inicial.

Validación cruzada (Cross Validation)

La validación cruzada divide el conjunto de datos varias veces para entrenar y evaluar, obteniendo así resultados de evaluación del rendimiento del modelo más estables y fiables.

Un enfoque común es:Validación cruzada de K pliegues：

  • El conjunto de datos se divide en K partes
  • Cada vez se usa una de las partes como conjunto de validación
  • El resto como conjunto de entrenamiento
  • Se repite K veces y se toma el promedio de los resultados

Ejemplo

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()

scores = cross_val_score(model, X, y, cv=5)

print("Cross-validation scores:", scores)
print("Mean score:", scores.mean())

En proyectos reales, normalmente se usa el método hold-out o la validación cruzada, no es necesario mezclarlos.

Ajuste de hiperparámetros por búsqueda en cuadrícula (GridSearchCV)

El rendimiento del modelo a menudo se ve muy afectado por la configuración de los hiperparámetros.
La búsqueda en cuadrícula recorre combinaciones de parámetros para encontrar automáticamente la configuración óptima.

Además, se combina con validación cruzada para que el ajuste de parámetros sea más robusto.

Ejemplo

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

parameters = {
    'kernel': ['linear', 'rbf'],
    'C': [1, 10, 100]
}

model = SVC()

grid_search = GridSearchCV(
    model,
    parameters,
    cv=5
)

grid_search.fit(X, y)

print("Best parameters:", grid_search.best_params_)
print("Best score:", grid_search.best_score_)
Otras extensiones