"Passei três dias ajustando manualmente a taxa de aprendizado e o número de camadas do meu modelo, e o resultado ainda estava longe do ideal. Se isso já aconteceu com você, a solução está na otimização automática de hiperparâmetros com Hyperopt." — Relato comum em fóruns de machine learning, como o Stack Overflow (2025).

Em 2026, a busca manual por hiperparâmetros é um dos maiores gargalos em projetos de machine learning. Com modelos cada vez mais complexos — desde transformers até redes neurais profundas —, encontrar a combinação ideal de parâmetros como taxa de aprendizado, número de camadas ou batch size pode consumir semanas de trabalho. É aí que entra o Hyperopt, uma biblioteca de otimização automática que usa algoritmos como TPE (Tree-structured Parzen Estimator) para explorar o espaço de busca de forma inteligente.

Diferente de métodos tradicionais como Grid Search ou Random Search, o Hyperopt aprende com tentativas anteriores e foca nas regiões mais promissoras. Em benchmarks recentes, como o estudo "Hyperopt: A Python Library for Model Selection and Hyperparameter Optimization" (Bergstra et al., 2013, disponível em ResearchGate), o Hyperopt demonstrou reduzir o tempo de tuning em até 60% comparado ao Grid Search, mantendo a mesma qualidade final. Empresas como a Spotify e a Yelp utilizam Hyperopt em pipelines de produção, reportando ganhos de produtividade significativos.

Neste tutorial, você vai montar um pipeline completo de otimização de hiperparâmetros para um modelo de classificação de imagens usando PyTorch e Hyperopt. Ao final, terá um modelo otimizado e um dashboard interativo com os resultados da busca.

Por que Hyperopt é uma ferramenta relevante em 2026

A otimização de hiperparâmetros sempre foi um desafio. Métodos como Grid Search testam todas as combinações possíveis, o que é inviável para espaços de busca grandes. Random Search é mais eficiente, mas ainda desperdiça recursos em regiões ruins. O Hyperopt resolve isso com três características principais:

• Amostragem inteligente: Usa TPE para modelar a distribuição de desempenho e sugerir novos pontos de busca.
• Suporte a espaços complexos: Permite definir espaços de busca com variáveis contínuas, discretas e condicionais.
• Integração simples: Funciona com qualquer framework (PyTorch, TensorFlow, scikit-learn) e oferece visualizações integradas.

Em 2026, o Hyperopt é mantido ativamente pela comunidade, com mais de 7 mil estrelas no GitHub e suporte a distributed tuning. Ele é a escolha padrão em empresas como a Spotify, que o utiliza para otimizar modelos de recomendação musical, e a Yelp, para sistemas de busca local.

Passo a passo: do setup à otimização completa

1. Configuração do ambiente

Você vai precisar de Python 3.10+ e das bibliotecas abaixo. Instale as dependências:

pip install hyperopt torch torchvision pandas matplotlib

O Hyperopt funciona com Python puro, mas para este tutorial usaremos PyTorch para o modelo de classificação. Certifique-se de ter uma GPU disponível para acelerar o treinamento, embora o exemplo funcione em CPU.

2. Definindo o modelo e o espaço de busca

Vamos criar um modelo simples de rede neural convolucional (CNN) para classificar imagens do dataset CIFAR-10. O espaço de busca incluirá hiperparâmetros como taxa de aprendizado, número de camadas convolucionais e dropout.

import hyperopt
from hyperopt import hp, fmin, tpe, Trials, STATUS_OK
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

Define o espaço de busca

espaco_busca = { "n_camadas": hp.choice("n_camadas", [2, 3, 4, 5]), "dropout": hp.uniform("dropout", 0.1, 0.5), "learning_rate": hp.loguniform("learning_rate", -11.5, -4.6), # log scale: 1e-5 a 1e-2 "out_channels_0": hp.choice("out_channels_0", [32, 64, 128]), "out_channels_1": hp.choice("out_channels_1", [32, 64, 128]), "out_channels_2": hp.choice("out_channels_2", [32, 64, 128]), "out_channels_3": hp.choice("out_channels_3", [32, 64, 128]), "out_channels_4": hp.choice("out_channels_4", [32, 64, 128]) }

Define o modelo com hiperparâmetros variáveis

def criar_modelo(params): n_camadas = params["n_camadas"] dropout = params["dropout"] learning_rate = params["learning_rate"]

camadas = []
in_channels = 3
for i in range(n_camadas):
    out_channels = params[f"out_channels_{i}"]
    camadas.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))
    camadas.append(nn.ReLU())
    camadas.append(nn.MaxPool2d(2))
    in_channels = out_channels

camadas.append(nn.AdaptiveAvgPool2d((1, 1)))
camadas.append(nn.Flatten())
camadas.append(nn.Linear(in_channels, 10))
camadas.append(nn.Dropout(dropout))

modelo = nn.Sequential(*camadas)
return modelo, learning_rate

O módulo hp do Hyperopt define o espaço de busca. hp.choice para opções discretas, hp.uniform para valores contínuos e hp.loguniform para valores em escala logarítmica.

3. Função objetivo para o Hyperopt

A função objetivo treina o modelo com os hiperparâmetros sugeridos e retorna a acurácia no conjunto de validação. O Hyperopt minimiza o valor retornado, então usamos 1 - acurácia como perda.

def objetivo(params):
    # Carrega dados CIFAR-10
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])
    train_dataset = datasets.CIFAR10(root="./data", train=True, download=True, transform=transform)
    val_dataset = datasets.CIFAR10(root="./data", train=False, download=True, transform=transform)
    train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)
    
    # Cria modelo e otimizador
    modelo, learning_rate = criar_modelo(params)
    criterio = nn.CrossEntropyLoss()
    otimizador = optim.Adam(modelo.parameters(), lr=learning_rate)
    
    # Treinamento
    for epoca in range(10):
        modelo.train()
        for imagens, rotulos in train_loader:
            otimizador.zero_grad()
            saida = modelo(imagens)
            perda = criterio(saida, rotulos)
            perda.backward()
            otimizador.step()
        
        # Validação
        modelo.eval()
        corretos = 0
        total = 0
        with torch.no_grad():
            for imagens, rotulos in val_loader:
                saida = modelo(imagens)
                _, previsto = torch.max(saida, 1)
                total += rotulos.size(0)
                corretos += (previsto == rotulos).sum().item()
        
        acuracia = corretos / total
    
    # Hyperopt minimiza, então retornamos 1 - acurácia
    perda = 1 - acuracia
    return {"loss": perda, "status": STATUS_OK, "acuracia": acuracia}

O Hyperopt não possui pruning nativo como o Optuna, mas podemos implementar uma lógica simples de parada antecipada se a acurácia for muito baixa nas primeiras épocas.

4. Executando a otimização

Agora, criamos um objeto Trials para armazenar os resultados e executamos a busca com o algoritmo TPE.

# Cria objeto Trials para armazenar resultados
trials = Trials()

Executa 50 tentativas com TPE

melhor = fmin( fn=objetivo, space=espaco_busca, algo=tpe.suggest, max_evals=50, trials=trials, rstate=np.random.default_rng(42) )

Melhores hiperparâmetros (convertendo índices para valores reais)

print("Melhores hiperparâmetros (índices):", melhor)

Para converter: hp.choice retorna índices, então precisamos mapear

n_camadas = [2, 3, 4, 5][melhor["n_camadas"]] dropout = melhor["dropout"] learning_rate = np.exp(melhor["learning_rate"]) # loguniform retorna log print(f"n_camadas: {n_camadas}, dropout: {dropout:.3f}, learning_rate: {learning_rate:.6f}")

Melhor acurácia

melhor_trial = trials.best_trial print("Melhor acurácia:", 1 - melhor_trial["result"]["loss"])

O fmin executa a otimização. O algoritmo TPE (Tree-structured Parzen Estimator) é o padrão do Hyperopt, baseado no artigo "Algorithms for Hyper-Parameter Optimization" (Bergstra et al., 2011, disponível em NeurIPS Proceedings).

5. Visualizando os resultados

O Hyperopt não oferece visualizações integradas como o Optuna, mas podemos usar o pandas e matplotlib para analisar os trials.

import pandas as pd
import matplotlib.pyplot as plt

Converte trials para DataFrame

resultados = [] for trial in trials.trials: resultado = trial["result"] params = trial["misc"]["vals"] # Converte índices para valores params_convertidos = {} for chave, valor in params.items(): if chave == "n_camadas": params_convertidos[chave] = [2, 3, 4, 5][valor[0]] elif chave.startswith("out_channels"): params_convertidos[chave] = [32, 64, 128][valor[0]] elif chave == "learning_rate": params_convertidos[chave] = np.exp(valor[0]) else: params_convertidos[chave] = valor[0] params_convertidos["acuracia"] = 1 - resultado["loss"] resultados.append(params_convertidos)

df = pd.DataFrame(resultados)

Gráfico de acurácia por tentativa

plt.figure(figsize=(10, 6)) plt.plot(df.index, df["acuracia"], marker="o", linestyle="-", alpha=0.7) plt.xlabel("Tentativa") plt.ylabel("Acurácia") plt.title("Evolução da Acurácia durante a Otimização com Hyperopt") plt.grid(True) plt.show()

Esse gráfico mostra como a acurácia melhora ao longo das tentativas, evidenciando a eficiência do TPE em focar nas regiões promissoras.

Dicas avançadas para 2026

• Distributed tuning: Use SparkTrials do Hyperopt para distribuir a busca em um cluster Spark, ideal para grandes espaços de busca.
• Espaços condicionais: Com hp.choice, você pode definir hiperparâmetros que só são ativados se outros forem escolhidos, como diferentes arquiteturas de rede.
• Integração com MLflow: Registre os trials no MLflow para rastreamento de experimentos e comparação entre execuções.

Conclusão

Neste tutorial, você aprendeu a usar o Hyperopt para otimizar hiperparâmetros de um modelo de classificação de imagens em 2026. Com a busca bayesiana baseada em TPE, é possível reduzir o tempo de tuning em até 60% comparado ao Grid Search, como demonstrado por Bergstra et al. (2013). A ferramenta é madura, bem documentada e amplamente adotada na indústria.

Agora é sua vez: aplique o Hyperopt no seu próximo projeto de machine learning e veja a diferença. Compartilhe seus resultados nos comentários!

Artigos Relacionados

• Como Usar IA para Criar Conteúdo de Alta Qualidade em 2026
• Do Dataset ao Ollama: Fine-Tuning de LLMs com Unsloth na Sua GPU em 2026
• 48% Não Testam, 40% Alucinam: Como Avaliar LLMs em 2026 — Guia Analítico