Optimización de Algoritmos de Machine Learning con Algoritmos Genéticos en Python

🚀 Introducción a la Optimización Evolutiva en Machine Learning

En el fascinante mundo del Machine Learning, el rendimiento de nuestros modelos a menudo depende críticamente de la elección de los hiperparámetros y de la selección de características adecuadas. Tradicionalmente, hemos recurrido a métodos como Grid Search o Random Search para estas tareas. Sin embargo, cuando el espacio de búsqueda es vasto y complejo, estos métodos pueden volverse computacionalmente prohibitivos y no siempre garantizan encontrar la solución óptima.

Aquí es donde entran en juego los algoritmos genéticos (AG), una potente clase de algoritmos de optimización inspirados en el proceso de selección natural y la genética. Ofrecen una alternativa robusta y eficiente para explorar espacios de búsqueda complejos, imitando la evolución para encontrar soluciones casi óptimas de manera inteligente. Este tutorial te sumergirá en el uso práctico de los AG para optimizar tus modelos de Machine Learning en Python.

¿Qué son los Algoritmos Genéticos? 🤔

Los algoritmos genéticos son algoritmos de búsqueda heurísticos inspirados en el proceso de evolución biológica. Funcionan con una población de soluciones candidatas, llamadas individuos o cromosomas, que evolucionan a lo largo de generaciones. Cada individuo representa una posible solución al problema, y su aptitud se evalúa mediante una función objetivo.

El proceso evolutivo implica los siguientes pasos clave:

1. Inicialización: Se crea una población inicial de individuos de forma aleatoria.
2. Evaluación de aptitud: Se calcula la aptitud de cada individuo en la población.
3. Selección: Los individuos más aptos tienen una mayor probabilidad de ser seleccionados para reproducirse.
4. Cruce (Crossover): Los individuos seleccionados intercambian material genético (características) para crear nuevos descendientes.
5. Mutación: Se introducen pequeños cambios aleatorios en los descendientes para mantener la diversidad genética y evitar caer en óptimos locales.
6. Reemplazo: Los nuevos descendientes reemplazan a una parte o a toda la población anterior.

Este ciclo se repite durante un número predefinido de generaciones o hasta que se alcanza un criterio de convergencia.

🛠️ Configuración del Entorno y Librerías Necesarias

Para este tutorial, utilizaremos Python y algunas librerías estándar de Machine Learning, junto con DEAP (Distributed Evolutionary Algorithms in Python), una librería muy potente para construir algoritmos evolutivos.

pip install numpy scikit-learn deap pandas matplotlib

Una vez instaladas, puedes importarlas en tu script:

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from deap import base, creator, tools, algorithms
import random
import matplotlib.pyplot as plt

🎯 Caso de Estudio 1: Optimización de Hiperparámetros con Algoritmos Genéticos

Nuestro primer objetivo será optimizar los hiperparámetros de un clasificador SVM (Support Vector Machine) utilizando algoritmos genéticos. El SVM es un modelo robusto, pero su rendimiento es muy sensible a la elección de hiperparámetros como C y gamma.

Utilizaremos un conjunto de datos sintético para simplificar y enfocarnos en el proceso de optimización.

1. Preparación de Datos 📊

Crearemos un dataset simple con make_classification de sklearn.datasets.

from sklearn.datasets import make_classification

# Generar un dataset sintético
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=5,
                           n_classes=2, random_state=42)

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

print(f"Dimensiones de X_train: {X_train.shape}")
print(f"Dimensiones de y_train: {y_train.shape}")

2. Definición del Problema con DEAP 🧬

DEAP requiere que definamos la estructura de nuestros individuos y el problema de optimización. En este caso, un individuo representará un conjunto de hiperparámetros (C, gamma).

# 1. Definir el tipo de problema: Maximizar la aptitud (accuracy)
creator.create("FitnessMax", base.Fitness, weights=(1.0,))

# 2. Definir el tipo de individuo: Una lista que contendrá los hiperparámetros
# El primer elemento será C (un flotante), el segundo será gamma (un flotante)
creator.create("Individual", list, fitness=creator.FitnessMax)

# Inicializar el Toolbox de DEAP
toolbox = base.Toolbox()

3. Generación de Individuos y Población 🧑‍🔬

Necesitamos funciones para generar valores aleatorios para C y gamma dentro de rangos razonables. Los algoritmos genéticos trabajan mejor cuando los rangos son explícitos.

Para C, usaremos un rango logarítmico (e.g., de 0.1 a 100). Para gamma, también un rango logarítmico (e.g., de 0.001 a 10).

# Definir los generadores de atributos (hiperparámetros)
# C en un rango logarítmico [0.1, 100]
toolbox.register("attr_C", lambda: 10**random.uniform(-1, 2)) # 10^-1 a 10^2

# gamma en un rango logarítmico [0.001, 10]
toolbox.register("attr_gamma", lambda: 10**random.uniform(-3, 1)) # 10^-3 a 10^1

# Registrar la forma en que se crea un individuo (una lista con C y gamma)
toolbox.register("individual", tools.initCycle, creator.Individual, 
                 (toolbox.attr_C, toolbox.attr_gamma), n=1)

# Registrar la forma en que se crea la población
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

4. Función de Evaluación (Fitness) 📈

La función de evaluación es el corazón del AG. Recibe un individuo (nuestros hiperparámetros) y devuelve su aptitud. Para la optimización de hiperparámetros, la aptitud suele ser la precisión del modelo en un conjunto de validación o mediante validación cruzada.

def evaluate_svm(individual):
    C_val, gamma_val = individual

    # Asegurarse de que los valores sean positivos y válidos para SVM
    if C_val <= 0 or gamma_val <= 0:
        return (0.0,) # Una aptitud de 0.0 para valores no válidos

    model = SVC(C=C_val, gamma=gamma_val, random_state=42)
    
    # Usar validación cruzada para una evaluación más robusta
    try:
        scores = cross_val_score(model, X_train, y_train, cv=5, scoring='accuracy')
        return (np.mean(scores),)
    except Exception as e:
        print(f"Error durante la validación cruzada: {e}")
        return (0.0,)

toolbox.register("evaluate", evaluate_svm)

5. Operadores Genéticos 🔄

Necesitamos definir cómo los individuos se seleccionan, cruzan y mutan.

• Selección: tools.selTournament es una buena opción general.
• Cruce: tools.cxBlend es adecuado para valores continuos como hiperparámetros.
• Mutación: tools.mutGaussian es útil para añadir ruido gaussiano a los valores continuos.

# Selección: Torneo con tamaño de torneo de 3
toolbox.register("select", tools.selTournament, tournsize=3)

# Cruce: Mezcla de los dos padres (alpha=0.5)
# C y gamma se mezclan independientemente
toolbox.register("mate", tools.cxBlend, alpha=0.5)

# Mutación: Añadir ruido gaussiano a C y gamma
# mu: media del ruido, sigma: desviación estándar, indpb: probabilidad de mutar cada atributo
toolbox.register("mutate", tools.mutGaussian, mu=[0, 0], sigma=[0.5, 0.5], indpb=0.2)

6. Ejecución del Algoritmo Genético 🚀

Ahora, podemos ejecutar el AG utilizando la función eaSimple de DEAP, que implementa un algoritmo genético estacionario.

def run_ga_hyperparameter_optimization(pop_size=50, generations=20, prob_crossover=0.7, prob_mutation=0.2):
    population = toolbox.population(n=pop_size)

    # Registrar estadísticas para el seguimiento de la evolución
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", np.mean)
    stats.register("std", np.std)
    stats.register("min", np.min)
    stats.register("max", np.max)

    # Almacenar el historial de las mejores aptitudes y parámetros
    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])

    # Ejecutar el algoritmo genético
    hof = tools.HallOfFame(1) # Para almacenar el mejor individuo encontrado
    population, log = algorithms.eaSimple(population, toolbox, cxpb=prob_crossover, mutpb=prob_mutation,
                                          ngen=generations, stats=stats, halloffame=hof, verbose=True)

    # Obtener el mejor individuo (hiperparámetros) y su aptitud
    best_individual = hof[0]
    best_C, best_gamma = best_individual
    best_accuracy = best_individual.fitness.values[0]

    print(f"\n--- Resultados de la Optimización de Hiperparámetros ---")
    print(f"Mejores Hiperparámetros: C={best_C:.4f}, gamma={best_gamma:.4f}")
    print(f"Mejor Precisión (CV): {best_accuracy:.4f}")

    # Entrenar el modelo final con los mejores hiperparámetros
    final_model = SVC(C=best_C, gamma=best_gamma, random_state=42)
    final_model.fit(X_train, y_train)
    test_predictions = final_model.predict(X_test)
    test_accuracy = accuracy_score(y_test, test_predictions)
    print(f"Precisión en el conjunto de prueba con los hiperparámetros óptimos: {test_accuracy:.4f}")

    return logbook, best_individual

# Ejecutar la optimización
logbook, best_params = run_ga_hyperparameter_optimization(pop_size=100, generations=30)

7. Visualización de los Resultados 📈

Es útil visualizar cómo la aptitud de la población evoluciona a lo largo de las generaciones.

gen, avg, max_ = logbook.select("gen", "avg", "max")
plt.figure(figsize=(10, 6))
plt.plot(gen, avg, label="Promedio de aptitud")
plt.plot(gen, max_, label="Máxima aptitud")
plt.xlabel("Generación")
plt.ylabel("Aptitud (Precisión)")
plt.title("Evolución de la Aptitud durante la Optimización de Hiperparámetros")
plt.legend()
plt.grid(True)
plt.show()

🌳 Caso de Estudio 2: Selección de Características con Algoritmos Genéticos

La selección de características es otro desafío común en Machine Learning. Un número excesivo de características puede llevar al overfitting, aumentar el tiempo de entrenamiento y dificultar la interpretabilidad del modelo. Los algoritmos genéticos pueden buscar eficientemente el subconjunto óptimo de características.

En este caso, un individuo será un vector binario donde cada posición representa una característica: 1 significa que la característica se incluye, 0 que no.

1. Preparación de Datos (reutilizando el anterior) 📊

Usaremos el mismo dataset sintético X, y definido previamente. En este escenario, n_features es 20, y n_informative es 10, lo que significa que hay 10 características redundantes o no informativas que podríamos querer eliminar.

# Reutilizar X_train, y_train, X_test, y_test
print(f"Número total de características: {X_train.shape[1]}")

2. Definición del Problema con DEAP para Selección de Características 🧬

Cada individuo será una lista de 0s y 1s, de longitud igual al número total de características.

# Reiniciar creator y toolbox para evitar conflictos con las definiciones anteriores
# Es una buena práctica si vas a redefinir el problema en el mismo script
# del creator. Por simplicidad, se puede omitir si se ejecuta en scripts separados.
# Si estás en un entorno interactivo como Jupyter, es posible que necesites reiniciar el kernel.

# Definir el tipo de problema: Maximizar la aptitud (accuracy) y minimizar el número de características
# Un peso positivo para la aptitud, un peso negativo para el número de características (minimizar)
creator.create("FitnessMultiObj", base.Fitness, weights=(1.0, -0.01)) # Peso negativo para minimizar

# Definir el tipo de individuo: Una lista que contendrá 0s y 1s
creator.create("IndividualFS", list, fitness=creator.FitnessMultiObj)

toolbox_fs = base.Toolbox()

num_features = X_train.shape[1]

# Generar un atributo binario (0 o 1)
toolbox_fs.register("attr_bool", random.randint, 0, 1)

# Registrar la forma en que se crea un individuo (lista de num_features booleanos)
toolbox_fs.register("individual", tools.initRepeat, creator.IndividualFS, toolbox_fs.attr_bool, num_features)

# Registrar la forma en que se crea la población
toolbox_fs.register("population", tools.initRepeat, list, toolbox_fs.individual)

3. Función de Evaluación (Fitness) para Selección de Características 📈

La aptitud ahora tendrá dos componentes: la precisión del modelo y el número de características seleccionadas. Queremos maximizar la precisión y minimizar el número de características.

def evaluate_features(individual):
    # Obtener los índices de las características seleccionadas
    selected_features_indices = [i for i, gene in enumerate(individual) if gene == 1]

    # Si no se selecciona ninguna característica, devolver una aptitud muy baja
    if not selected_features_indices:
        return (0.0, num_features) # Precisión 0, todas las características (penalidad máxima)

    # Crear un nuevo dataset con solo las características seleccionadas
    X_train_selected = X_train[:, selected_features_indices]

    # Entrenar un modelo (usaremos un clasificador simple, por ejemplo, LogisticRegression)
    from sklearn.linear_model import LogisticRegression
    model = LogisticRegression(solver='liblinear', random_state=42)
    
    # Evaluar con validación cruzada
    try:
        scores = cross_val_score(model, X_train_selected, y_train, cv=5, scoring='accuracy')
        accuracy = np.mean(scores)
        num_selected = len(selected_features_indices)
        return (accuracy, num_selected)
    except Exception as e:
        print(f"Error durante la validación cruzada para selección de características: {e}")
        return (0.0, num_features)

toolbox_fs.register("evaluate", evaluate_features)

4. Operadores Genéticos para Selección de Características 🔄

Para individuos binarios, usamos operadores de cruce y mutación específicos para ese tipo de genoma.

• Selección: tools.selTournament sigue siendo una buena elección.
• Cruce: tools.cxTwoPoint (cruce de dos puntos) es común para genomas binarios.
• Mutación: tools.mutFlipBit (mutación de bit) es ideal para individuos binarios.

# Selección: Torneo
toolbox_fs.register("select", tools.selTournament, tournsize=3)

# Cruce: Cruce de dos puntos
toolbox_fs.register("mate", tools.cxTwoPoint)

# Mutación: Invertir bits con una probabilidad
toolbox_fs.register("mutate", tools.mutFlipBit, indpb=0.05) # Pequeña probabilidad de voltear un bit

5. Ejecución del Algoritmo Genético para Selección de Características 🚀

def run_ga_feature_selection(pop_size=100, generations=40, prob_crossover=0.8, prob_mutation=0.1):
    population_fs = toolbox_fs.population(n=pop_size)

    stats_fs = tools.Statistics(lambda ind: ind.fitness.values)
    stats_fs.register("avg_acc", lambda ind: np.mean([i[0] for i in ind]))
    stats_fs.register("min_acc", lambda ind: np.min([i[0] for i in ind]))
    stats_fs.register("max_acc", lambda ind: np.max([i[0] for i in ind]))
    stats_fs.register("avg_features", lambda ind: np.mean([i[1] for i in ind]))
    stats_fs.register("min_features", lambda ind: np.min([i[1] for i in ind]))
    stats_fs.register("max_features", lambda ind: np.max([i[1] for i in ind]))

    logbook_fs = tools.Logbook()
    logbook_fs.header = ['gen', 'nevals', 'avg_acc', 'max_acc', 'avg_features', 'min_features']

    hof_fs = tools.HallOfFame(1) # Para el mejor individuo (solución multiobjetivo)

    population_fs, log_fs = algorithms.eaSimple(population_fs, toolbox_fs, cxpb=prob_crossover,
                                                  mutpb=prob_mutation, ngen=generations, 
                                                  stats=stats_fs, halloffame=hof_fs, verbose=True)

    best_individual_fs = hof_fs[0]
    selected_features_final = [i for i, gene in enumerate(best_individual_fs) if gene == 1]

    print(f"\n--- Resultados de la Selección de Características ---")
    print(f"Mejor Subconjunto de Características (índices): {selected_features_final}")
    print(f"Número de características seleccionadas: {len(selected_features_final)}")
    print(f"Aptitud (Precisión, #Características): {best_individual_fs.fitness.values}")

    # Evaluar el modelo final con las características seleccionadas en el conjunto de prueba
    X_test_selected = X_test[:, selected_features_final]
    final_model_fs = LogisticRegression(solver='liblinear', random_state=42)
    final_model_fs.fit(X_train[:, selected_features_final], y_train)
    test_predictions_fs = final_model_fs.predict(X_test_selected)
    test_accuracy_fs = accuracy_score(y_test, test_predictions_fs)
    print(f"Precisión en el conjunto de prueba con las características óptimas: {test_accuracy_fs:.4f}")

    return log_fs, best_individual_fs

# Ejecutar la optimización
log_fs, best_features_individual = run_ga_feature_selection(pop_size=80, generations=50)

6. Visualización de la Evolución de la Selección de Características 📈

Podemos graficar la evolución de la precisión y el número de características seleccionadas.

gen_fs = log_fs.select("gen")
avg_acc_fs = log_fs.select("avg_acc")
max_acc_fs = log_fs.select("max_acc")
avg_features_fs = log_fs.select("avg_features")

plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.plot(gen_fs, avg_acc_fs, label="Promedio de Precisión")
plt.plot(gen_fs, max_acc_fs, label="Máxima Precisión")
plt.xlabel("Generación")
plt.ylabel("Precisión")
plt.title("Evolución de la Precisión en Selección de Características")
plt.legend()
plt.grid(True)

plt.subplot(1, 2, 2)
plt.plot(gen_fs, avg_features_fs, label="Promedio de # Características")
plt.xlabel("Generación")
plt.ylabel("Número de Características")
plt.title("Evolución del Número de Características Seleccionadas")
plt.legend()
plt.grid(True)

plt.tight_layout()
plt.show()

💡 Consejos Avanzados y Consideraciones Prácticas

Los algoritmos genéticos son poderosos, pero su implementación óptima a menudo requiere experimentación y un buen entendimiento de sus parámetros.

Paralelización y Rendimiento 🚀

La evaluación de la aptitud, especialmente con validación cruzada, puede ser computacionalmente intensiva. DEAP soporta fácilmente la paralelización.

import multiprocessing

# En lugar de toolbox.register("evaluate", evaluate_svm),
# harías esto antes de la ejecución del algoritmo:

pool = multiprocessing.Pool() # Por defecto usa el número de CPUs disponibles
toolbox.register("map", pool.map)

# Asegúrate de cerrar el pool al finalizar
# pool.close()
# pool.join()

Elegir los Rangos de Búsqueda Adecuados 🎯

Definir rangos sensatos para los hiperparámetros es crucial. Si los rangos son demasiado amplios, el AG podría tardar mucho en encontrar una buena solución; si son demasiado estrechos, podría perderse el óptimo global. Utiliza el conocimiento del dominio o rangos usados comúnmente en la literatura.

Parámetros del Algoritmo Genético ⚙️

La configuración de pop_size, generations, cxpb (probabilidad de cruce) y mutpb (probabilidad de mutación) tiene un impacto significativo:

• pop_size: Una población más grande aumenta la diversidad pero también el coste computacional por generación.
• generations: Más generaciones permiten más evolución, pero también aumentan el tiempo total.
• cxpb: Una alta probabilidad de cruce favorece la exploración. Valores típicos están entre 0.7 y 0.9.
• mutpb: Una pequeña probabilidad de mutación ayuda a mantener la diversidad y evitar óptimos locales. Valores típicos entre 0.01 y 0.1.

Otras Formas de Optimización con AGs 📚

Además de la optimización de hiperparámetros y la selección de características, los AGs se pueden aplicar a:

• Diseño de arquitecturas de Redes Neuronales (Neuroevolución): Optimizar el número de capas, neuronas, funciones de activación, etc.
• Optimización de pesos de Redes Neuronales: Aunque el backpropagation es más común, los AGs pueden ser útiles en ciertos escenarios.
• Optimización de umbrales de clasificación.

Comparación con Otros Métodos de Optimización 🆚

✅ Conclusión

Has llegado al final de este completo tutorial sobre la optimización de algoritmos de Machine Learning utilizando algoritmos genéticos en Python. Hemos cubierto los fundamentos de los AGs, configurado el entorno con DEAP, y aplicado la optimización tanto a hiperparámetros como a la selección de características.

Los algoritmos genéticos representan una herramienta poderosa en tu arsenal de Machine Learning, permitiéndote ir más allá de las técnicas tradicionales de búsqueda para encontrar soluciones más eficientes y robustas en problemas complejos. ¡Ahora estás listo para experimentar con ellos en tus propios proyectos y descubrir el potencial de la optimización evolutiva!

¡Experimenta con diferentes configuraciones de AG, tipos de modelos y datasets para consolidar tu aprendizaje! La clave está en la práctica y la iteración.