Ajuste de hiperparâmetros: métodos, boas práticas e exemplos

A acurácia do seu modelo não está ruim porque você escolheu o algoritmo errado — é porque você nunca o ajustou.

Muita gente treina um modelo com as configurações padrão, vê a acurácia ficar ali na casa dos 80% e conclui que o algoritmo não serve para a tarefa. Mas o algoritmo não é o problema. Todo modelo de ML tem parâmetros que controlam como ele aprende, e esses parâmetros são definidos antes mesmo do treino começar. Se você acerta esses valores, dá para ganhar 10% a 20% a mais de acurácia com o mesmo modelo e os mesmos dados.

Esses parâmetros são os hiperparâmetros, e escolhê-los bem é o que separa um modelo que apenas quebra o galho de um que acerta quase sempre. Ajuste de hiperparâmetros é o processo de buscar a combinação que traz o melhor desempenho.

Neste artigo, vou te mostrar o que é ajuste de hiperparâmetros, as estratégias de busca que mais funcionam, como avaliar resultados sem se enganar e como rodar tudo em Python e R.

Se você está começando em ciência de dados e aprendizado de máquina, confira o Machine Learning Fundamentals in Python antes de partir para temas mais avançados.

O que é ajuste de hiperparâmetros?

Ajuste de hiperparâmetros é o processo de encontrar as configurações que fazem um modelo aprender melhor.

Todo modelo de ML tem dois tipos de números. Alguns são aprendidos a partir dos dados durante o treino, como os pesos de uma rede neural ou os pontos de divisão em uma árvore de decisão. Outros são definidos antes do treino começar — são os hiperparâmetros. Eles controlam como o modelo aprende: quão rápido, quão profundo, quanto deve generalizar ou memorizar.

Hiperparâmetros padrão existem para fazer o modelo rodar. Eles não foram feitos para entregar o melhor modelo para o seu conjunto de dados específico. É lógico que uma taxa de aprendizado padrão que funciona para classificação de imagens não terá o mesmo desempenho em dados tabulares. Uma profundidade de árvore padrão que vai bem em dados limpos pode superajustar em dados ruidosos. Você entendeu a ideia.

O processo de ajuste percorre diferentes combinações de valores de hiperparâmetros, treina um modelo para cada uma e mantém a que tem o melhor desempenho nos seus dados de validação. 

O ganho aqui muitas vezes supera o de trocar por um algoritmo “melhor” porém não ajustado.

Hiperparâmetros vs. parâmetros do modelo

A diferença está em quem define e quando define.

Parâmetros do modelo são aprendidos pelo algoritmo durante o treino. Você nunca os define manualmente. O processo de treino os ajusta olhando para os dados e minimizando uma função de perda. Por exemplo:

• Pesos e vieses em uma rede neural
• Coeficientes em uma regressão linear
• Limiares de divisão em uma árvore de decisão
• Vetores de suporte em uma SVM

Hiperparâmetros são escolhidos por você antes do treino começar. Eles controlam como o processo de aprendizado funciona, e o algoritmo não vai ajustá-los por conta própria. Se você não os definir, a biblioteca usa os padrões. Por exemplo:

• Taxa de aprendizado no gradiente descendente
• Número de árvores em uma random forest
• Força de regularização na regressão logística
• Tipo de kernel em uma SVM

Aqui vai uma comparação lado a lado:

Parâmetros do modelo respondem o que o modelo aprendeu. Hiperparâmetros respondem como ele aprendeu.

Como funciona o ajuste de hiperparâmetros

Ajustar é um loop.

Você começa escolhendo os hiperparâmetros que quer buscar e definindo um intervalo de valores para cada um. Depois treina um modelo com uma combinação, mede o desempenho nos dados de validação e usa esse resultado para decidir o que tentar em seguida.

O loop é assim:

1. Selecionar hiperparâmetros para ajustar e definir um intervalo de valores para cada um.
2. Treinar o modelo com uma combinação específica de valores.
3. Avaliar o desempenho em um conjunto de validação com uma métrica alinhada à sua tarefa.
4. Atualizar os hiperparâmetros com base no que você aprendeu — seguindo a próxima combinação de uma lista pré-definida ou usando o último resultado para guiar a próxima escolha.
5. Repetir até o desempenho parar de melhorar ou o seu orçamento de computação acabar.

A forma como você atualiza entre as iterações diferencia um método de busca do outro. No ajuste manual, você usa a intuição. No grid search, você percorre uma lista pré-definida. Métodos Bayesianos constroem um modelo do que tem mais chance de funcionar.

Vamos entrar nesses métodos agora.

Métodos de busca de hiperparâmetros

O método de busca que você escolhe determina quanto de computação você vai gastar e a probabilidade de encontrar bons hiperparâmetros.

Busca manual

A busca manual é o método mais simples. Você escolhe uma combinação de hiperparâmetros, treina o modelo, olha o resultado e ajusta com base no que viu.

Funciona quando o modelo é pequeno, há poucos hiperparâmetros e você já tem experiência com o algoritmo. Se você sabe que XGBoost costuma preferir uma taxa de aprendizado próxima de 0,05 e profundidade 6, pode começar por aí e ajustar conforme observar.

A busca manual não funciona quando o espaço de busca cresce. Três hiperparâmetros com cinco valores razoáveis cada já geram 125 combinações — ninguém ajusta 125 modelos na mão.

Grid search

Grid search testa todas as combinações de uma lista pré-definida de valores.

Você define uma grade — por exemplo, taxas de aprendizado [0.01, 0.05, 0.1] e profundidades de árvore [3, 5, 7] — e o grid search treina um modelo para cada uma das nove combinações. É exaustivo e reproduzível.

O problema é o custo computacional. 

Adicionar mais um hiperparâmetro com cinco valores multiplica por cinco o número de treinos. O grid search também desperdiça esforço em valores que pouco importam — se a profundidade da árvore quase não afeta sua métrica, ele ainda assim treina um modelo para cada profundidade listada.

Grid search é um bom padrão para espaços pequenos, com dois ou três hiperparâmetros.

Random search

Random search amostra combinações aleatórias a partir de intervalos, em vez de percorrer uma grade fixa.

Você define uma distribuição para cada hiperparâmetro e o random search sorteia combinações dessas distribuições. É mais eficiente que o grid search porque não desperdiça execuções em valores irrelevantes — se apenas um de três hiperparâmetros afeta o desempenho, o random search ainda explora o importante em vários valores diferentes.

Grid search versus random search

Random search é o melhor padrão quando há mais de dois hiperparâmetros.

Otimização Bayesiana

A otimização Bayesiana usa os resultados dos testes anteriores para decidir o que tentar em seguida.

Ela constrói um modelo probabilístico de como combinações de hiperparâmetros se mapeiam para desempenho e escolhe a próxima combinação com maior expectativa de score ou maior incerteza. Esse é o equilíbrio exploração–exploração: explorar regiões novas promissoras ou explorar melhor regiões já boas.

Métodos Bayesianos encontram bons hiperparâmetros com bem menos tentativas do que grid ou random search. A troca é que cada tentativa leva um pouco mais, pois o algoritmo precisa ajustar seu modelo interno antes de escolher o próximo ponto. Bibliotecas como Optuna e Hyperopt fazem isso para você.

Use otimização Bayesiana quando treinar é caro e você só pode fazer poucas execuções.

Successive halving e Hyperband

Successive halving e Hyperband reduzem o tempo de computação interrompendo cedo as execuções ruins.

O successive halving começa muitas combinações com um orçamento pequeno de treino, elimina a pior metade, dobra o orçamento dos sobreviventes e repete. 

O Hyperband envolve o successive halving e o executa várias vezes com diferentes divisões de orçamento, assim você não precisa adivinhar a configuração inicial ideal.

Ambos são úteis quando o treino é lento e o espaço de busca é grande. Funcionam melhor quando o desempenho inicial sinaliza bem o desempenho final — o que costuma valer para redes neurais e gradient boosting.

Veja a comparação entre os métodos:

Avaliando o desempenho dos hiperparâmetros

Ajustar não vai te levar longe se você não escolher intervalos de valores corretos.

Se a avaliação estiver errada, você vai escolher os hiperparâmetros errados. Há quatro pontos críticos: como dividir os dados, como medir o desempenho, qual métrica otimizar e como manter o conjunto de teste intacto.

Divisões de treino, validação e teste

Separe seus dados em três partes antes de ajustar.

O conjunto de treino é de onde o modelo aprende. O conjunto de validação é o que você usa para pontuar cada combinação durante o ajuste. O conjunto de teste é o que você usa uma única vez, no final, para medir como o modelo final se sai em dados inéditos.

Se você ajustar contra o conjunto de teste, vai obter uma acurácia que parece ótima, mas um modelo que performa abaixo do esperado em produção. Cada decisão tomada com base no teste vaza informação dele para o seu modelo.

Uma divisão comum é 60/20/20 para datasets médios ou 80/10/10 para maiores.

Validação cruzada

Validação cruzada é uma forma melhor de pontuar hiperparâmetros quando seu conjunto de validação é pequeno.

Você divide os dados de treino em k folds — geralmente 5 ou 10. Para cada combinação, treina em k-1 folds e valida no restante, depois gira. A pontuação final é a média dos folds.

A validação cruzada dá uma estimativa mais estável de generalização porque você não depende de uma divisão de validação sortuda (ou azarada). O custo é treinar k modelos por combinação em vez de um.

Use quando seu dataset é pequeno a ponto de uma única validação não ser confiável e quando você pode arcar com o custo extra.

Escolha das métricas de avaliação

A métrica que você otimiza deve refletir o que realmente importa para você.

Acurácia funciona para classificação balanceada, mas não faz sentido em problemas desbalanceados. Por exemplo, um modelo de fraude que prevê "não fraude" para tudo pode ter 99% de acurácia e mesmo assim perder todos os casos. Para classificação desbalanceada, use precisão, recall, F1 ou ROC-AUC. Para regressão, use RMSE, MAE ou R², dependendo de como outliers impactam.

Escolha uma métrica principal antes de começar e mantenha-se nela.

Evitando vazamento de dados

Vazamento de dados acontece quando informação do seu conjunto de validação ou teste entra no treino.

Algumas formas comuns de isso acontecer:

• Padronizar/normalizar o dataset inteiro antes de dividir, fazendo estatísticas da validação vazarem para o treino
• Engenharia de atributos usando valores-alvo do dataset completo
• Ajustar contra o conjunto de teste em vez de usar validação separada
• Usar séries temporais sem respeitar a ordem do tempo na divisão

Ajuste todo o pré-processamento apenas no conjunto de treino e depois aplique em validação e teste. No scikit-learn, é para isso que serve o Pipeline — ele encapsula pré-processamento e modelagem em um objeto que respeita as divisões.

Implementando o ajuste de hiperparâmetros

A maioria das bibliotecas de ML já traz ferramentas de busca e validação cruzada, então você não precisa implementar nada do zero.

Ajuste de hiperparâmetros em Python

O scikit-learn vem com duas classes que cobrem a maioria dos casos — GridSearchCV para grid search e RandomizedSearchCV para random search. Ambas envolvem qualquer estimador do scikit-learn, rodam validação cruzada para cada combinação e te entregam o melhor modelo no fim.

GridSearchCV recebe um estimador, um dicionário de valores de hiperparâmetros e o número de folds da validação cruzada. Ele treina um modelo para cada combinação e guarda a de melhor score.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=1000, random_state=42)

param_grid = {
    "n_estimators": [100, 200, 500],
    "max_depth": [5, 10, 20],
    "min_samples_leaf": [1, 5, 10],
}

grid = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=5)
grid.fit(X, y)

print(grid.best_params_)
print(grid.best_score_)

Resultados do GridSearchCV em Python

RandomizedSearchCV usa a mesma interface, mas amostra a partir de distribuições em vez de percorrer uma lista fixa. Assim você cobre um intervalo maior com um número fixo de tentativas.

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

param_dist = {
    "n_estimators": randint(100, 500),
    "max_depth": randint(3, 20),
    "min_samples_leaf": randint(1, 10),
}

random_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_dist,
    n_iter=30,
    cv=5,
    random_state=42,
)
random_search.fit(X, y)

print(random_search.best_params_)

Resultados do RandomizedSearchCV em Python

Para otimização Bayesiana, o Optuna é a escolha padrão. Ele seleciona a próxima combinação com base nos resultados anteriores, então converge mais rápido do que random search quando treinar é caro.

import optuna
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        "n_estimators": trial.suggest_int("n_estimators", 100, 500),
        "max_depth": trial.suggest_int("max_depth", 3, 20),
        "min_samples_leaf": trial.suggest_int("min_samples_leaf", 1, 10),
    }
    model = RandomForestClassifier(**params, random_state=42)
    return cross_val_score(model, X, y, cv=5).mean()

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=30)

print(study.best_params)

Resultados do Optuna em Python

Os métodos trial.suggest_* definem o espaço de busca, e o Optuna decide a próxima combinação com base nos scores já observados.

Ajuste de hiperparâmetros em R

R tem duas ótimas opções — caret e tidymodels. Ambas fazem o mesmo — definem uma grade, rodam validação cruzada e retornam o melhor modelo — mas o tidymodels é o padrão moderno.

Com o caret, você passa uma grade de ajuste para a função train() e especifica o método de reamostragem.

library(caret)

data <- iris
ctrl <- trainControl(method = "cv", number = 5)

grid <- expand.grid(
  mtry = c(2, 3, 4)
)

model <- train(
  Species ~ .,
  data = data,
  method = "rf",
  trControl = ctrl,
  tuneGrid = grid
)

print(model$bestTune)

Resultados do Caret em R

tidymodels separa o fluxo em etapas claras — especificação do modelo, receita de pré-processamento e grade de ajuste. É mais verboso, mas na prática escala melhor.

library(tidymodels)

data <- iris
split <- initial_split(data, prop = 0.8)
train_data <- training(split)

rf_spec <- rand_forest(
  mtry = tune(),
  trees = tune(),
  min_n = tune()
) |>
  set_engine("ranger") |>
  set_mode("classification")

grid <- grid_regular(
  mtry(range = c(2, 4)),
  trees(range = c(100, 500)),
  min_n(range = c(1, 10)),
  levels = 3
)

folds <- vfold_cv(train_data, v = 5)

results <- tune_grid(
  rf_spec,
  Species ~ .,
  resamples = folds,
  grid = grid
)

show_best(results, metric = "accuracy")

Resultados do Tidymodels em R

O fluxo é exatamente o mesmo do Python — você define o que buscar, define como pontuar e deixa a biblioteca tocar o loop.

Quais hiperparâmetros você deve ajustar?

Nem todo hiperparâmetro vale o esforço, porque geralmente poucos deles respondem pela maior parte do desempenho. Aqui vão os que mais importam, por família de modelo.

Árvores de decisão e random forests

Sempre ajuste estes três:

• Profundidade máxima controla até onde cada árvore pode crescer. Árvores rasas subajustam, árvores profundas superajustam. Geralmente é a primeira coisa a ajustar.
• Mínimo de amostras por folha define quantos pontos de treino um nó folha precisa. Valores mais altos forçam a árvore a generalizar em vez de memorizar linhas individuais.
• Número de árvores em uma random forest. Mais árvores geram um modelo mais estável, mas com retornos decrescentes após algumas centenas. Ajuste isso por último.

Modelos de gradient boosting

Gradient boosting (XGBoost, LightGBM, CatBoost) é mais sensível a hiperparâmetros do que random forests. Foque nesses:

• A taxa de aprendizado controla quanto cada nova árvore corrige as anteriores. Taxas menores são mais precisas, mas exigem mais árvores. É o hiperparâmetro mais importante para ajustar.
• Número de estimadores é o número de rounds de boosting. Relacione com a taxa de aprendizado — se reduzir um, aumente o outro.
• Profundidade da árvore controla a complexidade de cada árvore individual. Boosting costuma preferir árvores mais rasas do que random forests, tipicamente entre 3 e 8.

Máquinas de vetores de suporte (SVM)

Em SVMs, a escolha dos hiperparâmetros pesa muito, talvez mais do que em outros modelos:

• C controla o equilíbrio entre uma margem ampla e classificar corretamente os pontos de treino. C maior significa menos regularização.
• Gamma controla até onde vai a influência de um ponto de treino. Gamma baixo significa influência distante; alto, próxima.
• O kernel determina o formato da fronteira de decisão que a SVM pode aprender. Comece com rbf para problemas não lineares e linear para dados esparsos e de alta dimensionalidade.

Redes neurais

Redes neurais têm o maior espaço de busca entre as famílias comuns. Ajuste estes primeiro:

• Taxa de aprendizado é o hiperparâmetro mais importante em deep learning. Alta demais e o treino diverge; baixa demais e nunca converge. Teste ordens de grandeza como 1e-4, 1e-3, 1e-2.
• Tamanho do batch afeta a velocidade de treino e a acurácia final. Batches maiores treinam mais rápido por época, mas costumam generalizar pior.
• Otimizador (Adam, SGD com momentum, AdamW) muda como a rede atualiza os pesos. Adam é um bom padrão.
• Épocas indicam quantas vezes o modelo vê todo o conjunto de treino. Use early stopping em vez de ajustar isso na mão.

Desafios comuns no ajuste de hiperparâmetros

Ajustar é caro, principalmente quando você quer testar vários valores por parâmetro e tem muitos parâmetros para ajustar. Veja alguns desafios comuns.

Custo computacional é a maior restrição. Cada combinação testada implica treinar um modelo completo, e a validação cruzada multiplica isso pelo número de folds. Uma grade com 100 combinações e CV de 5 folds são 500 ajustes de modelo. Se cada ajuste leva 10 minutos, são mais de três dias.

Espaços de busca grandes crescem multiplicativamente. Cinco hiperparâmetros com cinco valores cada geram 3.125 combinações. Aqui o grid search deixa de ser opção e dá lugar ao random search ou a métodos Bayesianos.

Retornos decrescentes aparecem mais cedo do que se imagina. As primeiras tentativas costumam trazer os maiores ganhos. As próximas 50 talvez rendam mais 1% de acurácia. Em certo ponto, é melhor investir a computação em coletar mais dados ou melhorar as features.

A troca acurácia x tempo pesa mais em produção do que no desenvolvimento. Um modelo 0,5% melhor que leva o dobro do tempo para treinar pode não valer a pena se você retreina diariamente. Defina antes quanto de acurácia vale quanto de computação.

Boas práticas para ajuste de hiperparâmetros

Alguns hábitos que valem ouro ao ajustar os hiperparâmetros de um modelo de machine learning:

• Ajuste primeiro os hiperparâmetros mais influentes: Taxa de aprendizado para boosting e redes neurais. Profundidade máxima para árvores. C e gamma para SVMs. Coloque esses na faixa certa antes de mexer no resto.
• Comece com random search em espaços grandes: Grid search desperdiça computação em hiperparâmetros pouco relevantes. Random search cobre melhor o espaço e é a escolha certa quando há mais de dois ou três hiperparâmetros.
• Use validação cruzada: Uma única validação pode ser sorte. Cinco folds te dão uma estimativa bem mais honesta de generalização.
• Defina intervalos realistas: Se a taxa de aprendizado está em [0.001, 100], você vai perder tempo em valores que nunca funcionam. Comece por faixas conhecidas do seu algoritmo e depois estreite conforme os resultados.
• Registre seus experimentos: Logue valores de hiperparâmetros, score e seed de cada execução. Ferramentas como MLflow, Weights & Biases ou até CSV funcionam. Sem isso, você não reproduz resultados.
• Defina um orçamento de computação: Decida quantas tentativas você pode fazer antes de começar, não depois. Isso força a escolher um método de busca compatível e evita ajustar por mais tempo do que o necessário.

Erros comuns no ajuste de hiperparâmetros

A maioria dos fracassos no ajuste vem de erros fáceis de evitar. Alguns deles:

• Confundir hiperparâmetros com parâmetros do modelo. Pesos e coeficientes são aprendidos durante o treino. Você não os define na mão nem os “ajusta”. Se está tentando ajustar algo que o algoritmo deveria aprender, você misturou os conceitos.
• Ajustar contra o conjunto de teste. Cada decisão baseada no score de teste vaza informação para o modelo. O número final será otimista e o modelo em produção vai render menos. Use validação separada ou validação cruzada.
• Buscar grades desnecessariamente grandes. Uma grade com sete hiperparâmetros e dez valores cada tem dez milhões de combinações. Isso é impraticável. Reduza antes de começar, escolhendo os dois ou três mais importantes e dando intervalos realistas.
• Otimizar a métrica errada. Acurácia em dados desbalanceados gera um modelo que sempre prevê a classe majoritária. Escolha uma métrica alinhada ao que importa e defina-a antes de começar a ajustar.
• Mudar muitos hiperparâmetros de uma vez no ajuste manual. Se você altera a taxa de aprendizado e o tamanho do batch no mesmo passo, não vai saber o que causou a mudança. Ajuste um por vez quando estiver na mão.

Ajuste de hiperparâmetros vs. engenharia de atributos

Ambos melhoram seu modelo, mas atuam em partes diferentes do problema.

Engenharia de atributos (features) melhora os dados de entrada. Você cria novas features, codifica variáveis categóricas, trata ausências e reduz ruído. Features melhores dão sinais mais úteis para o modelo aprender.

Ajuste de hiperparâmetros melhora como o modelo aprende a partir das features que você fornece. Ele muda o comportamento do algoritmo, não os dados.

Os dois são complementares. Engenharia de atributos costuma trazer os maiores ganhos no início do projeto, quando os dados ainda estão crus e o modelo perde sinais óbvios. Ajuste de hiperparâmetros traz ganhos menores porém consistentes quando as features já estão em bom nível.

Se o seu modelo travou e você não sabe por onde começar, olhe os erros. Se ele perde padrões que parecem óbvios nos dados, o problema é de features. Se está superajustando ou subajustando, o problema é de ajuste.

Por que o ajuste de hiperparâmetros importa em machine learning

Ajustar é etapa padrão em qualquer workflow de ML.

Muitas vezes ele traz ganhos maiores do que trocar de algoritmo. Por exemplo, uma random forest bem ajustada frequentemente supera um modelo de gradient boosting mal ajustado nos mesmos dados, mesmo o boosting sendo mais sofisticado. 

Ajustar também ajuda a generalizar. Hiperparâmetros como profundidade máxima e taxa de dropout controlam diretamente o quanto o modelo pode superajustar. Acertar esses valores é o que diferencia um modelo que memoriza o treino de um que performa bem em dados novos.

Em produção, o ajuste transforma um MVP em um sistema confiável. 

Os padrões te ajudam a começar, mas não mantêm o modelo competitivo frente a retreinos e exigências do negócio. Todo time sério de ML trata o ajuste como parte do processo.

Conclusão

Ajuste de hiperparâmetros é um ciclo iterativo de buscar, avaliar e afunilar o que funciona para os seus dados.

Os melhores resultados vêm da combinação de três coisas: um método de busca que caiba no seu orçamento de computação, uma validação que dê uma métrica relevante e um rastreamento de experimentos que permita revisar o que foi testado.

Comece com random search ou grid search. Parta para otimização Bayesiana quando treinar ficar caro o suficiente para o número de tentativas realmente importar. Em qualquer caso, ajuste os hiperparâmetros relevantes do seu modelo, mantenha o conjunto de teste limpo e registre cada execução.

Se você está de olho em uma carreira em machine learning, inscreva-se na trilha Machine Learning Engineer para ficar pronto para o mercado em 2026.