Grid Search y Random Search

from pyspark.ml.classification import RandomForestClassifier
from pyspark.ml.evaluation import BinaryClassificationEvaluator
from pyspark.ml.tuning import CrossValidator, ParamGridBuilder
from pyspark.ml.feature import VectorAssembler

# ============================================================
# PASO 1: Preparar datos
# ============================================================
# Supongamos df_train con columnas: feature1, feature2, ..., label

assembler = VectorAssembler(
    inputCols=["feature1", "feature2", "feature3", "feature4"],  # Características
    outputCol="features"
)

df_assembled = assembler.transform(df_train)

# ============================================================
# PASO 2: Definir modelo base
# ============================================================
rf = RandomForestClassifier(
    featuresCol="features",
    labelCol="label",
    seed=42  # Para reproducibilidad
)

# ============================================================
# PASO 3: Construir grid de hiperparámetros
# ============================================================
# Definimos espacio de búsqueda: Θ = Θ₁ × Θ₂ × Θ₃ × Θ₄
paramGrid = ParamGridBuilder() \
    .addGrid(rf.numTrees, [10, 50, 100, 200]) \          # |Θ₁| = 4
    .addGrid(rf.maxDepth, [5, 10, 15, 20]) \              # |Θ₂| = 4
    .addGrid(rf.maxBins, [16, 32, 64]) \                  # |Θ₃| = 3
    .addGrid(rf.subsamplingRate, [0.6, 0.8, 1.0]) \       # |Θ₄| = 3
    .build()

# Tamaño del espacio: |Θ| = 4 × 4 × 3 × 3 = 144 configs

print(f"Total de configuraciones a evaluar: {len(paramGrid)}")
# Output: Total de configuraciones a evaluar: 144

# ============================================================
# PASO 4: Definir evaluador
# ============================================================
# Métrica: AUC-ROC (área bajo curva ROC)
evaluator = BinaryClassificationEvaluator(
    labelCol="label",
    rawPredictionCol="rawPrediction",
    metricName="areaUnderROC"  # Maximizar AUC
)

# ============================================================
# PASO 5: Configurar CrossValidator
# ============================================================
# K-fold CV con K=5, paralelización en 4 partitions
cv = CrossValidator(
    estimator=rf,                    # Modelo a tunear
    estimatorParamMaps=paramGrid,    # Grid de hiperparámetros
    evaluator=evaluator,             # Métrica de evaluación
    numFolds=5,                      # K=5 folds
    parallelism=4,                   # 4 configs en paralelo
    seed=42                          # Reproducibilidad
)

# Complejidad: 144 configs × 5 folds = 720 entrenamientos
# Con parallelism=4: 720 / 4 = 180 tareas secuenciales

# ============================================================
# PASO 6: Ejecutar Grid Search (¡esto puede tomar tiempo!)
# ============================================================
print("Iniciando Grid Search con 5-fold CV...")
print("Esto entrenará 720 modelos (144 configs × 5 folds)")

cvModel = cv.fit(df_assembled)

print("Grid Search completado!")

# ============================================================
# PASO 7: Extraer mejor modelo y parámetros
# ============================================================
# Mejor modelo encontrado
bestModel = cvModel.bestModel

# Extraer hiperparámetros óptimos
print("\n========== RESULTADOS ==========")
print(f"Mejor numTrees: {bestModel.getNumTrees}")
print(f"Mejor maxDepth: {bestModel.getMaxDepth()}")
print(f"Mejor maxBins: {bestModel.getMaxBins()}")
print(f"Mejor subsamplingRate: {bestModel.getSubsamplingRate()}")

# Mejor AUC en validación (promedio de 5 folds)
best_auc = max(cvModel.avgMetrics)
print(f"\nMejor AUC (CV): {best_auc:.4f}")

# ============================================================
# PASO 8: Analizar todos los resultados
# ============================================================
# cvModel.avgMetrics contiene AUC promedio para cada config
results = []
for idx, (params, auc) in enumerate(zip(paramGrid, cvModel.avgMetrics)):
    config = {
        "config_id": idx,
        "numTrees": params[rf.numTrees],
        "maxDepth": params[rf.maxDepth],
        "maxBins": params[rf.maxBins],
        "subsamplingRate": params[rf.subsamplingRate],
        "avg_auc": auc
    }
    results.append(config)

# Convertir a DataFrame para análisis
import pandas as pd
results_df = pd.DataFrame(results)

# Top 5 configuraciones
print("\nTop 5 configuraciones:")
print(results_df.nlargest(5, "avg_auc"))

# ============================================================
# PASO 9: Evaluar en test set
# ============================================================
df_test_assembled = assembler.transform(df_test)

predictions = bestModel.transform(df_test_assembled)
test_auc = evaluator.evaluate(predictions)

print(f"\nAUC en Test Set: {test_auc:.4f}")

# ============================================================
# PASO 10: Análisis de sensibilidad (opcional)
# ============================================================
# Ver cómo cada hiperparámetro afecta el rendimiento
print("\n========== SENSIBILIDAD POR HIPERPARÁMETRO ==========")

for param_name in ["numTrees", "maxDepth", "maxBins", "subsamplingRate"]:
    print(f"\n{param_name}:")
    sensitivity = results_df.groupby(param_name)["avg_auc"].agg(["mean", "std"])
    print(sensitivity)

# Ejemplo Output:
#             mean       std
# numTrees
# 10          0.8234    0.0123
# 50          0.8567    0.0089
# 100         0.8623    0.0076  ← Mejor promedio
# 200         0.8619    0.0081

# ============================================================
# OBSERVACIONES FINALES
# ============================================================
# 1. Grid Search garantiza encontrar el óptimo DENTRO del grid
# 2. Con 144 configs × 5 folds = 720 entrenamientos
# 3. Paralelización (parallelism=4) reduce tiempo 4x
# 4. El mejor modelo se puede usar directamente: bestModel.transform(...)
# 5. Considerar Random Search si el espacio es > 500 configs