Phase 02 - Lesson 12

Ajuste de hiperparámetros

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

Los hiperparámetros son las perillas que giras antes de que comience el entrenamiento. Girarlos bien es la diferencia entre un modelo mediocre y uno genial.

Tipo: Construcción Idioma: Python Requisitos previos: Fase 2, Lección 11 (Métodos de conjunto) Tiempo: ~90 minutos

Objetivos de aprendizaje

• Implementar búsqueda de cuadrícula, búsqueda aleatoria y optimización bayesiana desde cero y comparar su eficiencia de muestra
• Explicar por qué la búsqueda aleatoria supera a la búsqueda en cuadrícula cuando la mayoría de los hiperparámetros tienen una dimensionalidad efectiva baja
• Cree un bucle de optimización bayesiano utilizando un modelo sustituto y una función de adquisición para guiar la búsqueda.
• Diseñar una estrategia de ajuste de hiperparámetros que evite el sobreajuste del conjunto de validación mediante una validación cruzada adecuada

El problema

Su modelo de aumento de gradiente tiene una tasa de aprendizaje, cantidad de árboles, profundidad máxima, muestras mínimas por hoja, proporción de submuestra y proporción de muestra de columna. Son seis hiperparámetros. Si cada uno tiene 5 valores razonables, la cuadrícula tiene 5^6 = 15,625 combinaciones. Entrenar cada uno toma 10 segundos. Son 43 horas de cálculo para probarlos todos.

La búsqueda en cuadrícula es el enfoque obvio y el peor a escala. La búsqueda aleatoria funciona mejor con menos cálculo. La optimización bayesiana funciona aún mejor al aprender de evaluaciones anteriores. Saber qué estrategia utilizar y qué hiperparámetros realmente importan ahorra días de tiempo desperdiciado en la GPU.

El concepto

Parámetros frente a hiperparámetros

Los parámetros se aprenden durante el entrenamiento (pesos, sesgos, umbrales divididos). Los hiperparámetros se establecen antes de que comience el entrenamiento y controlan cómo ocurre el aprendizaje.

Búsqueda de cuadrícula

La búsqueda de cuadrícula evalúa cada combinación de valores especificados. Es exhaustivo y fácil de entender, pero escala exponencialmente con el número de hiperparámetros.

Grid for 2 hyperparameters:

  learning_rate: [0.01, 0.1, 1.0]
  max_depth:     [3, 5, 7]

  Evaluations: 3 x 3 = 9 combinations

  (0.01, 3)  (0.01, 5)  (0.01, 7)
  (0.1,  3)  (0.1,  5)  (0.1,  7)
  (1.0,  3)  (1.0,  5)  (1.0,  7)

La búsqueda en cuadrícula tiene un defecto fundamental: si un hiperparámetro importa y el otro no, la mayoría de las evaluaciones se desperdician. Obtiene solo 3 valores únicos del parámetro importante de 9 evaluaciones.

Búsqueda aleatoria

La búsqueda aleatoria muestra hiperparámetros de distribuciones en lugar de una cuadrícula. Con el mismo presupuesto de 9 evaluaciones, obtienes 9 valores únicos de cada hiperparámetro.

flowchart LR
    subgraph Grid Search
        G1[3 unique learning rates]
        G2[3 unique max depths]
        G3[9 total evaluations]
    end

    subgraph Random Search
        R1[9 unique learning rates]
        R2[9 unique max depths]
        R3[9 total evaluations]
    end

Por qué la grilla de ritmos aleatorios (Bergstra & Bengio, 2012):

• La mayoría de los hiperparámetros tienen una dimensionalidad efectiva baja. Por lo general, sólo 1 o 2 de 6 hiperparámetros son importantes para un problema determinado.
• La búsqueda en cuadrícula desperdicia evaluaciones en dimensiones sin importancia.
• La búsqueda aleatoria cubre las dimensiones importantes con mayor densidad para el mismo presupuesto.
• En 60 pruebas aleatorias, tienes un 95 % de posibilidades de encontrar un punto dentro del 5 % del óptimo (si existe uno en el espacio de búsqueda).

Optimización bayesiana

La búsqueda aleatoria ignora los resultados. No aprende que las altas tasas de aprendizaje causan divergencia o que la profundidad 3 supera consistentemente a la profundidad 10. La optimización bayesiana utiliza evaluaciones anteriores para decidir dónde buscar a continuación.

flowchart TD
    A[Define search space] --> B[Evaluate initial random points]
    B --> C[Fit surrogate model to results]
    C --> D[Use acquisition function to pick next point]
    D --> E[Evaluate the model at that point]
    E --> F{Budget exhausted?}
    F -->|No| C
    F -->|Yes| G[Return best hyperparameters found]

Los dos componentes clave:

Modelo sustituto: Un modelo económico de evaluar (generalmente un proceso gaussiano) que se aproxima a la costosa función objetivo. Proporciona tanto una predicción como una estimación de la incertidumbre en cualquier punto del espacio de búsqueda.

Función de adquisición: Decide dónde evaluar a continuación equilibrando la explotación (búsqueda cerca de puntos buenos conocidos) y la exploración (búsqueda donde la incertidumbre es alta). Opciones comunes:

• Mejora esperada (EI): ¿Cuánta mejora con respecto a lo mejor actual esperamos en este momento?
• Límite superior de confianza (UCB): Predicción más un múltiplo de incertidumbre. Un UCB más alto significa prometedor o inexplorado.
• Probabilidad de mejora (PI): ¿Cuál es la probabilidad de que este punto supere al mejor actual?

La optimización bayesiana normalmente encuentra mejores hiperparámetros que la búsqueda aleatoria con entre 2 y 5 veces menos evaluaciones. La sobrecarga de ajustar el modelo sustituto es insignificante en comparación con entrenar el modelo real.

Parada anticipada

No es necesario que todas las carreras de entrenamiento terminen. Si una configuración es claramente mala después de 10 épocas, deténgala y continúe. Esta es una parada temprana en el contexto de la búsqueda de hiperparámetros.

Estrategias:

• Basado en paciencia: Deténgase si la pérdida de validación no ha mejorado durante N épocas consecutivas
• Poda mediana: Deténgase si el resultado intermedio de la prueba es peor que la mediana de las pruebas completadas en el mismo paso
• Hiperbanda: Asigne presupuestos pequeños a muchas configuraciones y luego aumente progresivamente el presupuesto para las mejores.

La hiperbanda es particularmente eficaz. Inicia 81 configuraciones con 1 época cada una, mantiene el tercio superior, les da 3 épocas, mantiene el tercio superior, y así sucesivamente. Esto encuentra buenas configuraciones entre 10 y 50 veces más rápido que evaluar todas las configuraciones para el presupuesto total.

Programadores de tasas de aprendizaje

La tasa de aprendizaje es casi siempre el hiperparámetro más importante. En lugar de mantenerlo fijo, los programadores lo ajustan durante el entrenamiento.

Importancia del hiperparámetro

No todos los hiperparámetros importan por igual. La investigación sobre bosques aleatorios (Probst et al., 2019) y el aumento de gradiente muestra patrones consistentes:

Alta importancia:

• Tasa de aprendizaje (siempre sintoniza primero)
• Número de estimadores/épocas (use parada anticipada en lugar de ajuste)
• Fuerza de regularización

Importancia media:

• Profundidad máxima / número de capas
• Muestras mínimas por hoja / peso de descomposición
• Relación de submuestra

Baja importancia:

• Funciones máximas (para bosques aleatorios)
• Elección de función de activación específica
• Tamaño del lote (dentro de un rango razonable)

Ajuste los importantes primero y deje el resto en los valores predeterminados.

Estrategia práctica

flowchart TD
    A[Start with defaults] --> B[Coarse random search: 20-50 trials]
    B --> C[Identify important hyperparameters]
    C --> D[Fine random or Bayesian search: 50-100 trials in narrowed space]
    D --> E[Final model with best hyperparameters]
    E --> F[Retrain on full training data]

El flujo de trabajo concreto:

1. Comience con los valores predeterminados de la biblioteca. Los eligen profesionales experimentados y, a menudo, ya han recorrido el 80% del camino.
2. Búsqueda aleatoria aproximada. Rangos amplios, 20 a 50 ensayos. Utilice la parada temprana para acabar rápidamente con las malas carreras.
3. Analizar resultados. ¿Qué hiperparámetros se correlacionan con el rendimiento? Limita el espacio de búsqueda.
4. Búsqueda fina. Optimización bayesiana o búsqueda aleatoria enfocada en el espacio reducido. 50-100 ensayos.
5. Vuelva a entrenar con todos los datos de entrenamiento con los mejores hiperparámetros encontrados.

Integración de validación cruzada

Ajustar los hiperparámetros en una única división de validación es arriesgado. Los mejores hiperparámetros podrían sobreajustarse al pliegue de validación específico. La validación cruzada anidada resuelve esto mediante el uso de dos bucles:

• Bucle exterior (evaluación): divide los datos en tren+val y prueba. Informa sobre el desempeño imparcial.
• Bucle interno (sintonización): divide train+val en train y val. Encuentra los mejores hiperparámetros.

flowchart TD
    D[Full Dataset] --> O1[Outer Fold 1: Test]
    D --> O2[Outer Fold 2: Test]
    D --> O3[Outer Fold 3: Test]
    D --> O4[Outer Fold 4: Test]
    D --> O5[Outer Fold 5: Test]

    O1 --> I1[Inner 5-fold CV on remaining data]
    I1 --> T1[Best hyperparams for fold 1]
    T1 --> E1[Evaluate on outer test fold 1]

    O2 --> I2[Inner 5-fold CV on remaining data]
    I2 --> T2[Best hyperparams for fold 2]
    T2 --> E2[Evaluate on outer test fold 2]

Cada pliegue exterior encuentra sus mejores hiperparámetros de forma independiente. Las puntuaciones externas son una estimación insesgada del rendimiento de la generalización.

Con sklearn:

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.ensemble import GradientBoostingRegressor

inner_cv = GridSearchCV(
    GradientBoostingRegressor(),
    param_grid={
        "learning_rate": [0.01, 0.05, 0.1],
        "max_depth": [2, 3, 5],
        "n_estimators": [50, 100, 200],
    },
    cv=5,
    scoring="neg_mean_squared_error",
)

outer_scores = cross_val_score(
    inner_cv, X, y, cv=5, scoring="neg_mean_squared_error"
)

print(f"Nested CV MSE: {-outer_scores.mean():.4f} +/- {outer_scores.std():.4f}")

Esto es costoso (5 pliegues externos x 5 pliegues internos x 27 puntos de cuadrícula = 675 ajustes de modelo), pero le brinda una estimación de rendimiento confiable. Úselo cuando informe los resultados finales en artículos o cuando haya mucho en juego en la decisión.

Consejos prácticos

Comience con la tasa de aprendizaje. Siempre es el hiperparámetro más importante para los métodos basados ​​en gradientes. Una mala tasa de aprendizaje hace que todo lo demás sea irrelevante. Corrija otros hiperparámetros en los valores predeterminados y barre primero la tasa de aprendizaje.

Utilice distribuciones logarítmicas uniformes para la tasa de aprendizaje y la regularización. La diferencia entre 0,001 y 0,01 es tan importante como la diferencia entre 0,1 y 1,0. La búsqueda lineal desperdicia presupuesto en gran medida.

Utilice la parada anticipada en lugar de ajustar n_estimators. Para el impulso y las redes neuronales, establezca n_estimators o épocas altas y deje que la parada temprana decida cuándo detenerse. Esto elimina un hiperparámetro de la búsqueda.

Asignación de presupuesto. Gaste el 60% de su presupuesto de ajuste en los 2 hiperparámetros más importantes. Gasta el 40% restante en todo lo demás. Los dos primeros representan la mayor parte de la variación de rendimiento.

La escala importa. Nunca busque el tamaño del lote en una escala logarítmica (16, 32, 64 están bien). Busque siempre la tasa de aprendizaje en una escala logarítmica. Haga coincidir la distribución de búsqueda con la forma en que el hiperparámetro afecta al modelo.

En caso de duda: búsqueda aleatoria con el doble de hiperparámetros que ensayos (p. ej., 6 hiperparámetros = más de 12 ensayos como mínimo). Se sorprenderá de la frecuencia con la que la búsqueda aleatoria con 50 ensayos supera a la búsqueda en cuadrícula cuidadosamente diseñada.

Constrúyelo

Paso 1: Búsqueda en cuadrícula desde cero

El código en code/tuning.py implementa búsqueda en cuadrícula, búsqueda aleatoria y un optimizador bayesiano simple desde cero.

def grid_search(model_fn, param_grid, X_train, y_train, X_val, y_val):
    keys = list(param_grid.keys())
    values = list(param_grid.values())
    best_score = -float("inf")
    best_params = None
    n_evals = 0

    for combo in itertools.product(*values):
        params = dict(zip(keys, combo))
        model = model_fn(**params)
        model.fit(X_train, y_train)
        score = evaluate(model, X_val, y_val)
        n_evals += 1

        if score > best_score:
            best_score = score
            best_params = params

    return best_params, best_score, n_evals

Paso 2: Búsqueda aleatoria desde cero

def random_search(model_fn, param_distributions, X_train, y_train,
                  X_val, y_val, n_iter=50, seed=42):
    rng = np.random.RandomState(seed)
    best_score = -float("inf")
    best_params = None

    for _ in range(n_iter):
        params = {k: sample(v, rng) for k, v in param_distributions.items()}
        model = model_fn(**params)
        model.fit(X_train, y_train)
        score = evaluate(model, X_val, y_val)

        if score > best_score:
            best_score = score
            best_params = params

    return best_params, best_score, n_iter

Paso 3: Optimización bayesiana (simplificada)

La idea central: ajustar un proceso gaussiano a los pares observados (hiperparámetro, puntuación) y luego usar una función de adquisición para decidir dónde buscar a continuación.

class SimpleBayesianOptimizer:
    def __init__(self, search_space, n_initial=5):
        self.search_space = search_space
        self.n_initial = n_initial
        self.X_observed = []
        self.y_observed = []

    def _kernel(self, x1, x2, length_scale=1.0):
        dists = np.sum((x1[:, None, :] - x2[None, :, :]) ** 2, axis=2)
        return np.exp(-0.5 * dists / length_scale ** 2)

    def _fit_gp(self, X_new):
        X_obs = np.array(self.X_observed)
        y_obs = np.array(self.y_observed)
        y_mean = y_obs.mean()
        y_centered = y_obs - y_mean

        K = self._kernel(X_obs, X_obs) + 1e-4 * np.eye(len(X_obs))
        K_star = self._kernel(X_new, X_obs)

        L = np.linalg.cholesky(K)
        alpha = np.linalg.solve(L.T, np.linalg.solve(L, y_centered))
        mu = K_star @ alpha + y_mean

        v = np.linalg.solve(L, K_star.T)
        var = 1.0 - np.sum(v ** 2, axis=0)
        var = np.maximum(var, 1e-6)

        return mu, var

    def _expected_improvement(self, mu, var, best_y):
        sigma = np.sqrt(var)
        z = (mu - best_y) / (sigma + 1e-10)
        ei = sigma * (z * norm_cdf(z) + norm_pdf(z))
        return ei

    def suggest(self):
        if len(self.X_observed) < self.n_initial:
            return sample_random(self.search_space)

        candidates = [sample_random(self.search_space) for _ in range(500)]
        X_cand = np.array([to_vector(c) for c in candidates])
        mu, var = self._fit_gp(X_cand)
        ei = self._expected_improvement(mu, var, max(self.y_observed))
        return candidates[np.argmax(ei)]

    def observe(self, params, score):
        self.X_observed.append(to_vector(params))
        self.y_observed.append(score)

El sustituto del médico de cabecera proporciona dos cosas en cada punto candidato: una puntuación prevista (mu) y una incertidumbre (var). La mejora esperada los equilibra: favorece puntos donde el modelo predice puntuaciones altas O donde la incertidumbre es alta. Al principio, la mayoría de los puntos tienen una gran incertidumbre, por lo que el optimizador los explora. Posteriormente, se centra en la región más prometedora.

Paso 4: comparar todos los métodos

Ejecute los tres métodos con el mismo objetivo sintético y compare. Esta comparación utiliza un contenedor simplificado que llama a cada optimizador con una función objetivo directa (sin entrenamiento de modelo), por lo que API difiere de las implementaciones basadas en modelos anteriores:

def synthetic_objective(params):
    lr = params["learning_rate"]
    depth = params["max_depth"]
    return -(np.log10(lr) + 2) ** 2 - (depth - 4) ** 2 + 10

param_grid = {
    "learning_rate": [0.001, 0.01, 0.1, 1.0],
    "max_depth": [2, 3, 4, 5, 6, 7, 8],
}

grid_best = None
grid_score = -float("inf")
grid_history = []
for combo in itertools.product(*param_grid.values()):
    params = dict(zip(param_grid.keys(), combo))
    score = synthetic_objective(params)
    grid_history.append((params, score))
    if score > grid_score:
        grid_score = score
        grid_best = params

param_dist = {
    "learning_rate": ("log_float", 0.001, 1.0),
    "max_depth": ("int", 2, 8),
}

rand_best = None
rand_score = -float("inf")
rand_history = []
rng = np.random.RandomState(42)
for _ in range(28):
    params = {k: sample(v, rng) for k, v in param_dist.items()}
    score = synthetic_objective(params)
    rand_history.append((params, score))
    if score > rand_score:
        rand_score = score
        rand_best = params

optimizer = SimpleBayesianOptimizer(param_dist, n_initial=5)
bayes_history = []
for _ in range(28):
    params = optimizer.suggest()
    score = synthetic_objective(params)
    optimizer.observe(params, score)
    bayes_history.append((params, score))
bayes_score = max(s for _, s in bayes_history)

print(f"{'Method':<20} {'Best Score':>12} {'Evaluations':>12}")
print("-" * 50)
print(f"{'Grid Search':<20} {grid_score:>12.4f} {len(grid_history):>12}")
print(f"{'Random Search':<20} {rand_score:>12.4f} {len(rand_history):>12}")
print(f"{'Bayesian Opt':<20} {bayes_score:>12.4f} {len(bayes_history):>12}")

Con el mismo presupuesto, la optimización bayesiana suele encontrar la mejor puntuación más rápidamente porque no desperdicia evaluaciones en regiones claramente malas. La búsqueda aleatoria cubre más terreno que la búsqueda en cuadrícula. La búsqueda de cuadrícula solo gana cuando tiene muy pocos hiperparámetros y puede permitirse el lujo de ser exhaustiva.

Úsalo

Optuna en la práctica

Optuna es la biblioteca recomendada para un ajuste serio de hiperparámetros. Admite poda, búsqueda distribuida y visualización lista para usar.

import optuna

def objective(trial):
    lr = trial.suggest_float("learning_rate", 1e-4, 1e-1, log=True)
    n_est = trial.suggest_int("n_estimators", 50, 500)
    max_depth = trial.suggest_int("max_depth", 2, 10)

    model = GradientBoostingRegressor(
        learning_rate=lr,
        n_estimators=n_est,
        max_depth=max_depth,
    )
    model.fit(X_train, y_train)
    return mean_squared_error(y_val, model.predict(X_val))

study = optuna.create_study(direction="minimize")
study.optimize(objective, n_trials=100)

print(f"Best params: {study.best_params}")
print(f"Best MSE: {study.best_value:.4f}")

Características clave de Optuna:

• suggest_float(..., log=True) para los parámetros que se buscan mejor en escala logarítmica (tasa de aprendizaje, regularización)
• suggest_int para parámetros enteros
• suggest_categorical para opciones discretas
• MedianPruner incorporado para detener tempranamente las malas pruebas
• study.trials_dataframe() para análisis

Optuna con Poda

La poda detiene tempranamente las pruebas poco prometedoras, lo que ahorra una computación masiva. Aquí está el patrón:

import optuna
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        "learning_rate": trial.suggest_float("lr", 1e-4, 0.5, log=True),
        "max_depth": trial.suggest_int("max_depth", 2, 10),
        "n_estimators": trial.suggest_int("n_estimators", 50, 500),
        "subsample": trial.suggest_float("subsample", 0.5, 1.0),
    }

    model = GradientBoostingRegressor(**params)
    scores = cross_val_score(model, X_train, y_train, cv=3,
                             scoring="neg_mean_squared_error")
    mean_score = -scores.mean()

    trial.report(mean_score, step=0)
    if trial.should_prune():
        raise optuna.TrialPruned()

    return mean_score

pruner = optuna.pruners.MedianPruner(n_startup_trials=10, n_warmup_steps=5)
study = optuna.create_study(direction="minimize", pruner=pruner)
study.optimize(objective, n_trials=200)

El MedianPruner detiene una prueba si su valor intermedio es peor que la mediana de todas las pruebas completadas en el mismo paso. La poda requiere llamar a trial.report() para informar métricas intermedias y a trial.should_prune() para verificar si se debe detener la prueba. El n_startup_trials=10 garantiza que al menos 10 pruebas se completen por completo antes de que se inicie la poda. Esto generalmente ahorra entre un 40% y un 60% del cálculo total.

Sintonizadores integrados de sklearn

Para experimentos rápidos, sklearn proporciona GridSearchCV, RandomizedSearchCV y HalvingRandomSearchCV:

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import loguniform, randint

param_dist = {
    "learning_rate": loguniform(1e-4, 0.5),
    "max_depth": randint(2, 10),
    "n_estimators": randint(50, 500),
}

search = RandomizedSearchCV(
    GradientBoostingRegressor(),
    param_dist,
    n_iter=100,
    cv=5,
    scoring="neg_mean_squared_error",
    random_state=42,
    n_jobs=-1,
)
search.fit(X_train, y_train)
print(f"Best params: {search.best_params_}")
print(f"Best CV MSE: {-search.best_score_:.4f}")

Utilice loguniform de scipy para la tasa de aprendizaje y la regularización. Utilice randint para hiperparámetros de números enteros. La bandera n_jobs=-1 se paraleliza en todos los núcleos de la CPU.

Errores comunes en el ajuste de hiperparámetros

Fuga de datos a través del preprocesamiento. Si coloca un escalador en el conjunto de datos completo antes de la validación cruzada, la inentrenamiento del pliegue de validación se filtra al entrenamiento. Siempre coloque el preprocesamiento dentro de un Pipeline para que encaje solo en el pliegue de entrenamiento.

Sobreadaptación al conjunto de validación. La ejecución de miles de pruebas entrena de manera efectiva en el conjunto de validación. Utilice validación cruzada anidada para estimaciones de rendimiento finales, o mantenga un conjunto de prueba separado que nunca toque durante el ajuste.

Buscando en un rango demasiado limitado. Si su mejor valor se encuentra en el límite de su espacio de búsqueda, no ha realizado una búsqueda lo suficientemente amplia. El valor óptimo podría estar fuera de su rango. Compruebe siempre si los mejores parámetros están en los bordes.

Ignorando los efectos de interacción. La tasa de aprendizaje y el número de estimadores interactúan fuertemente en el impulso. Una tasa de aprendizaje baja necesita más estimadores. Ajustarlos de forma independiente da peores resultados que ajustarlos juntos.

No se utiliza la detención anticipada para modelos iterativos. Para el aumento de gradiente y las redes neuronales, establezca n_estimators o epochs en un valor alto y utilice la detención anticipada. Esto es estrictamente mejor que ajustar el número de iteraciones como un hiperparámetro.

Ejercicios

1. Ejecute una búsqueda en cuadrícula y una búsqueda aleatoria con el mismo presupuesto total (por ejemplo, 50 evaluaciones). Compara las mejores puntuaciones encontradas. Realiza el experimento 10 veces con diferentes semillas. ¿Con qué frecuencia gana la búsqueda aleatoria?

2. Implementar Hyperband desde cero. Comience con 81 configuraciones, cada una entrenada para 1 época. Mantenga el tercio superior en cada ronda y triplique su presupuesto. Compare el cálculo total (suma de todas las épocas en todas las configuraciones) con la ejecución de 81 configuraciones para el presupuesto completo.

3. Agregue un programador de tasa de aprendizaje (recocido de coseno) a la implementación de aumento de gradiente de la Lección 11. ¿Ayuda en comparación con una tasa de aprendizaje fija?

4. Utilice Optuna para ajustar un RandomForestClassifier en un conjunto de datos real (por ejemplo, el conjunto de datos sobre cáncer de mama de sklearn). Utilice optuna.visualization.plot_param_importances(study) para ver qué hiperparámetros son más importantes. ¿Coincide con la clasificación de importancia de esta lección?

5. Implementar una función de adquisición simple (Mejora esperada) y demostrar exploración versus explotación. Trace la media y la incertidumbre del modelo sustituto y muestre dónde elige IE evaluar a continuación.

Términos clave

Lectura adicional

• Bergstra & Bengio: Búsqueda aleatoria para optimización de hiperparámetros (2012) -- el artículo que mostraba una cuadrícula de ritmos aleatorios
• Snoek et al., Optimización bayesiana práctica de algoritmos de machine learning (2012) -- Optimización bayesiana para ML
• Li et al., Hyperband: A Novel Bandit-Based Approach (2018) -- el artículo de Hyperband
• Optuna: un marco de optimización de hiperparámetros de próxima generación: el documento de Optuna
• Probst et al., Tunability: Importancia de los hiperparámetros (2019) - qué hiperparámetros importan