Phase 02 - Lesson 12

Ajuste de hiperparâmetros

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

Hiperparâmetros são os botões que você gira antes do início do treinamento. Transformá-los bem é a diferença entre um modelo medíocre e um excelente.

Tipo: Construir Idioma: Python Pré-requisitos: Fase 2, Lição 11 (Métodos de Ensemble) Tempo: ~90 minutos

Objetivos de aprendizagem

• Implementar pesquisa em grade, pesquisa aleatória e otimização bayesiana do zero e comparar a eficiência da amostra
• Explique por que a pesquisa aleatória supera a pesquisa em grade quando a maioria dos hiperparâmetros tem baixa dimensionalidade efetiva
• Construir um loop de otimização Bayesiano usando um modelo substituto e uma função de aquisição para orientar a pesquisa
• Projetar uma estratégia de ajuste de hiperparâmetros que evite o ajuste excessivo do conjunto de validação por meio de validação cruzada adequada

O problema

Seu modelo de aumento de gradiente tem uma taxa de aprendizado, número de árvores, profundidade máxima, amostras mínimas por folha, proporção de subamostra e proporção de amostra de coluna. São seis hiperparâmetros. Se cada um tiver 5 valores razoáveis, a grade terá 5 ^ 6 = 15.625 combinações. Cada treinamento leva 10 segundos. São 43 horas de computação para experimentar todos eles.

A pesquisa em grade é a abordagem óbvia e a pior em escala. A pesquisa aleatória funciona melhor com menos computação. A otimização bayesiana tem um desempenho ainda melhor ao aprender com avaliações anteriores. Saber qual estratégia usar e quais hiperparâmetros realmente importam economiza dias de desperdício de tempo de GPU.

O Conceito

Parâmetros vs Hiperparâmetros

Os parâmetros são aprendidos durante o treinamento (pesos, desvios, limites de divisão). Os hiperparâmetros são definidos antes do início do treinamento e controlam como o aprendizado acontece.

Pesquisa em grade

A pesquisa em grade avalia cada combinação de valores especificados. É exaustivo e fácil de entender, mas aumenta exponencialmente com o 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)

A pesquisa em grade tem uma falha fundamental: se um hiperparâmetro for importante e o outro não, a maioria das avaliações será desperdiçada. Você obtém apenas 3 valores exclusivos do parâmetro importante em 9 avaliações.

Pesquisa aleatória

A pesquisa aleatória mostra hiperparâmetros de distribuições em vez de uma grade. Com o mesmo orçamento de 9 avaliações, você obtém 9 valores exclusivos 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 que grade de batidas aleatórias (Bergstra & Bengio, 2012):

• A maioria dos hiperparâmetros possui baixa dimensionalidade efetiva. Apenas 1-2 dos 6 hiperparâmetros geralmente são importantes para um determinado problema.
• A pesquisa em grade desperdiça avaliações em dimensões sem importância.
• A pesquisa aleatória cobre as dimensões importantes de forma mais densa para o mesmo orçamento.
• Em 60 tentativas aleatórias, você tem 95% de chance de encontrar um ponto dentro de 5% do ótimo (se existir algum no espaço de busca).

Otimização Bayesiana

A pesquisa aleatória ignora os resultados. Ele não aprende que altas taxas de aprendizado causam divergência ou que a profundidade 3 supera consistentemente a profundidade 10. A otimização bayesiana usa avaliações anteriores para decidir onde pesquisar em seguida.

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]

Os dois componentes principais:

Modelo substituto: Um modelo barato de avaliar (geralmente um processo gaussiano) que se aproxima da cara função objetivo. Ele fornece uma previsão e uma estimativa de incerteza em qualquer ponto do espaço de busca.

Função de aquisição: decide onde avaliar em seguida, equilibrando exploração (pesquisa perto de pontos bons conhecidos) e exploração (pesquisa onde a incerteza é alta). Escolhas comuns:

• Melhoria Esperada (EI): Quanta melhoria em relação ao melhor atual esperamos neste momento?
• Limite Superior de Confiança (UCB): Previsão mais um múltiplo de incerteza. Um UCB mais alto significa promissor ou inexplorado.
• Probabilidade de Melhoria (PI): Qual é a probabilidade de este ponto superar o melhor atual?

A otimização bayesiana normalmente encontra hiperparâmetros melhores do que a pesquisa aleatória com 2 a 5 vezes menos avaliações. A sobrecarga de ajuste do modelo substituto é insignificante em comparação com o treinamento do modelo real.

Parada antecipada

Nem todo treino precisa terminar. Se uma configuração estiver claramente ruim após 10 épocas, pare-a e siga em frente. Esta é uma parada antecipada no contexto da pesquisa de hiperparâmetros.

Estratégias:

• Baseado em paciência: Pare se a perda de validação não tiver melhorado por N épocas consecutivas
• Remoção da mediana: Pare se o resultado intermediário do ensaio for pior que a mediana dos ensaios concluídos na mesma etapa
• Hiperbanda: aloque orçamentos pequenos para muitas configurações e aumente progressivamente o orçamento para as melhores

A hiperbanda é particularmente eficaz. Ele inicia 81 configurações com 1 época cada, mantém o terço superior, dá a elas 3 épocas, mantém o terço superior e assim por diante. Isso encontra boas configurações de 10 a 50 vezes mais rápido do que avaliar todas as configurações para o orçamento total.

Programadores de taxas de aprendizagem

A taxa de aprendizagem é quase sempre o hiperparâmetro mais importante. Em vez de mantê-lo fixo, os programadores ajustam-no durante o treinamento.

Importância do hiperparâmetro

Nem todos os hiperparâmetros são igualmente importantes. Pesquisas sobre florestas aleatórias (Probst et al., 2019) e aumento de gradiente mostram padrões consistentes:

Alta importância:

• Taxa de aprendizagem (sempre sintonize primeiro)
• Número de estimadores/épocas (use parada antecipada em vez de ajuste)
• Força de regularização

Importância média:

• Profundidade máxima / número de camadas
• Amostras mínimas por folha / redução de peso
• Razão de subamostra

Baixa importância:

• Recursos máximos (para florestas aleatórias)
• Escolha específica da função de ativação
• Tamanho do lote (dentro do intervalo razoável)

Ajuste os mais importantes primeiro, deixe o resto como padrão.

Estratégia Prática

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]

O fluxo de trabalho concreto:

1. Comece com os padrões da biblioteca. Eles são escolhidos por profissionais experientes e geralmente chegam a 80% do caminho.
2. Pesquisa aleatória grosseira. Amplas faixas, 20 a 50 tentativas. Use a parada antecipada para eliminar rapidamente as corridas ruins.
3. Analise os resultados. Quais hiperparâmetros se correlacionam com o desempenho? Limite o espaço de pesquisa.
4. Pesquisa fina. Otimização bayesiana ou pesquisa aleatória focada no espaço estreito. 50-100 tentativas.
5. Retreine todos os dados de treinamento com os melhores hiperparâmetros encontrados.

Integração de validação cruzada

Ajustar hiperparâmetros em uma única divisão de validação é arriscado. Os melhores hiperparâmetros podem se ajustar demais à dobra de validação específica. A validação cruzada aninhada resolve isso usando dois loops:

• Loop externo (avaliação): divide os dados em train+val e test. Relata desempenho imparcial.
• Loop interno (ajuste): divide train+val em train e val. Encontra os melhores 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 dobra externa encontra seus melhores hiperparâmetros de forma independente. As pontuações externas são uma estimativa imparcial do desempenho da generalização.

Com 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}")

Isso é caro (5 dobras externas x 5 dobras internas x 27 pontos de grade = 675 ajustes de modelo), mas fornece uma estimativa de desempenho confiável. Use-o ao relatar os resultados finais em artigos ou quando o risco da decisão for alto.

Dicas Práticas

Comece com a taxa de aprendizado. É sempre o hiperparâmetro mais importante para métodos baseados em gradiente. Uma taxa de aprendizagem ruim torna todo o resto irrelevante. Corrija outros hiperparâmetros nos padrões e varra primeiro a taxa de aprendizado.

Use distribuições log-uniformes para taxa de aprendizagem e regularização. A diferença entre 0,001 e 0,01 é tão importante quanto a diferença entre 0,1 e 1,0. A pesquisa linear desperdiça orçamento em grande escala.

Use a parada antecipada em vez de ajustar n_estimadores. Para redes neurais e de reforço, defina n_estimadores ou épocas altas e deixe a parada antecipada decidir quando parar. Isso remove um hiperparâmetro da pesquisa.

Alocação de orçamento. Gaste 60% de seu orçamento de ajuste nos dois hiperparâmetros mais importantes. Gaste os 40% restantes em todo o resto. Os 2 primeiros respondem pela maior parte da variação de desempenho.

A escala é importante. Nunca pesquise o tamanho do lote em uma escala logarítmica (16, 32, 64 são adequados). Sempre pesquise a taxa de aprendizagem em uma escala logarítmica. Combine a distribuição da pesquisa com a forma como o hiperparâmetro afeta o modelo.

Em caso de dúvida: pesquisa aleatória com 2x o número de hiperparâmetros como ensaios (por exemplo, 6 hiperparâmetros = 12+ ensaios no mínimo). Você ficará surpreso com a frequência com que a pesquisa aleatória com 50 tentativas supera a pesquisa em grade cuidadosamente projetada.

Construa

Etapa 1: pesquisa em grade do zero

O código em code/tuning.py implementa pesquisa em grade, pesquisa aleatória e um otimizador bayesiano simples do zero.

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

Etapa 2: pesquisa aleatória do zero

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

Etapa 3: Otimização Bayesiana (simplificada)

A ideia central: ajustar um processo gaussiano aos pares observados (hiperparâmetro, pontuação) e, em seguida, usar uma função de aquisição para decidir onde procurar em seguida.

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)

O substituto GP fornece duas coisas em cada ponto candidato: uma pontuação prevista (mu) e uma incerteza (var). A Melhoria Esperada equilibra isso: favorece pontos onde o modelo prevê pontuações altas OU onde a incerteza é alta. No início, a maioria dos pontos apresenta alta incerteza, então o otimizador explora. Posteriormente, concentra-se na região mais promissora.

Etapa 4: compare todos os métodos

Execute todos os três métodos no mesmo objetivo sintético e compare. Esta comparação usa um wrapper simplificado que chama cada otimizador com uma função objetivo direta (sem treinamento de modelo), então API difere das implementações baseadas em modelo acima:

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}")

Com o mesmo orçamento, a otimização bayesiana geralmente encontra a melhor pontuação mais rapidamente porque não desperdiça avaliações em regiões claramente ruins. A pesquisa aleatória cobre mais terreno do que a pesquisa em grade. A pesquisa em grade só vence quando você tem poucos hiperparâmetros e pode se dar ao luxo de ser exaustivo.

Use-o

Optuna na Prática

Optuna é a biblioteca recomendada para ajustes sérios de hiperparâmetros. Ele suporta remoção, pesquisa distribuída e visualização pronta para uso.

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}")

Principais recursos do Optuna:

• suggest_float(..., log=True) para parâmetros melhor pesquisados em escala logarítmica (taxa de aprendizagem, regularização)
• suggest_int para parâmetros inteiros
• suggest_categorical para escolhas discretas
• MedianPruner integrado para interrupção antecipada de testes ruins
• study.trials_dataframe() para análise

Optuna com Poda

A remoção interrompe testes pouco promissores antecipadamente, economizando computação massiva. Aqui está o padrão:

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)

O MedianPruner interrompe uma tentativa se seu valor intermediário for pior que a mediana de todas as tentativas concluídas na mesma etapa. A poda requer chamar trial.report() para relatar métricas intermediárias e trial.should_prune() para verificar se o teste deve ser interrompido. O n_startup_trials=10 garante que pelo menos 10 tentativas sejam concluídas totalmente antes do início da remoção. Isso normalmente economiza de 40 a 60% do cálculo total.

Sintonizadores integrados do sklearn

Para experimentos rápidos, o sklearn fornece GridSearchCV, RandomizedSearchCV e 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}")

Use loguniform do scipy para taxa de aprendizagem e regularização. Use randint para hiperparâmetros inteiros. O sinalizador n_jobs=-1 é paralelizado em todos os núcleos da CPU.

Erros comuns no ajuste de hiperparâmetros

Vazamento de dados por meio de pré-processamento. Se você ajustar um escalonador no conjunto de dados completo antes da validação cruzada, as informações da dobra de validação vazarão para o treinamento. Sempre coloque o pré-processamento dentro de um Pipeline para que caiba apenas na dobra de treinamento.

Ajuste excessivo ao conjunto de validação. A execução de milhares de testes treina efetivamente o conjunto de validação. Use a validação cruzada aninhada para estimativas finais de desempenho ou realize um conjunto de testes separado que você nunca toca durante o ajuste.

Pesquisando um intervalo muito estreito. Se o seu melhor valor estiver no limite do seu espaço de pesquisa, você não pesquisou suficientemente. O valor ideal pode estar fora do seu intervalo. Verifique sempre se os melhores parâmetros estão nas bordas.

Ignorando os efeitos de interação. A taxa de aprendizagem e o número de estimadores interagem fortemente no impulso. Uma baixa taxa de aprendizado precisa de mais estimadores. Ajustá-los de forma independente dá resultados piores do que ajustá-los juntos.

Não usar parada antecipada para modelos iterativos. Para aumento de gradiente e redes neurais, defina n_estimators ou épocas com um valor alto e use parada antecipada. Isso é estritamente melhor do que ajustar o número de iterações como um hiperparâmetro.

Exercícios

1. Execute a pesquisa em grade e a pesquisa aleatória com o mesmo orçamento total (por exemplo, 50 avaliações). Compare as melhores pontuações encontradas. Execute o experimento 10 vezes com sementes diferentes. Com que frequência a pesquisa aleatória vence?

2. Implemente a hiperbanda do zero. Comece com 81 configurações, cada uma treinada por 1 época. Mantenha o 1/3 do topo em cada rodada e triplique seu orçamento. Compare a computação total (soma de todas as épocas em todas as configurações) com a execução de 81 configurações para o orçamento total.

3. Adicione um agendador de taxa de aprendizagem (recozimento de cosseno) à implementação de aumento de gradiente da Lição 11. Isso ajuda em comparação com uma taxa de aprendizagem fixa?

4. Use Optuna para ajustar um RandomForestClassifier em um conjunto de dados real (por exemplo, conjunto de dados de câncer de mama do sklearn). Use optuna.visualization.plot_param_importances(study) para ver quais hiperparâmetros são mais importantes. Corresponde à classificação de importância desta lição?

5. Implementar uma função de aquisição simples (Melhoria Esperada) e demonstrar exploração versus exploração. Faça um gráfico da média e da incerteza do modelo substituto e mostre onde a IE escolhe avaliar em seguida.

Termos-chave

Leitura Adicional

• Bergstra & Bengio: Random Search for Hyper-Parameter Optimization (2012) - o artigo que mostrou grade de batidas aleatórias
• Snoek et al., Otimização Bayesiana Prática de Algoritmos de Aprendizado de Máquina (2012) - Otimização bayesiana para ML
• Li et al., Hyperband: A Novel Bandit-Based Approach (2018) - o artigo Hyperband
• Optuna: uma estrutura de otimização de hiperparâmetros de próxima geração - o artigo da Optuna
• Probst et al., Tunability: Importance of Hyperparameters (2019) - quais hiperparâmetros são importantes