Quando se trata de construir modelos de machine learning, a escolha dos hiperparâmetros certos pode ser a diferença entre um modelo mediano e um modelo de alta performance. Hiperparâmetros são configurações que governam o processo de treinamento do modelo e, ao contrário dos parâmetros aprendidos durante o treinamento, eles precisam ser definidos antes que o modelo comece a aprender. Mas como encontrar os melhores valores para esses hiperparâmetros? É aí que entram técnicas como Grid Search, Random Search e Bayesian Optimization.
O que são Hiperparâmetros?
Antes de mergulharmos nas técnicas de otimização, é importante entender o que são hiperparâmetros. Eles são configurações que controlam o comportamento do algoritmo de machine learning. Por exemplo, em uma rede neural, a taxa de aprendizado, o número de camadas ocultas e o número de neurônios por camada são hiperparâmetros. Em um modelo de árvore de decisão, a profundidade máxima da árvore e o número mínimo de amostras por folha são exemplos de hiperparâmetros.
A escolha adequada desses hiperparâmetros é essencial, pois eles podem afetar significativamente o desempenho do modelo. No entanto, encontrar os valores ideais manualmente pode ser uma tarefa demorada e muitas vezes ineficiente. É aí que as técnicas de otimização de hiperparâmetros entram em cena.
O que é Otimização de Hiperparâmetros?
Antes de aprofundarmos nos métodos, é importante diferenciar parâmetros de hiperparâmetros:
- Parâmetros: São aprendidos pelo modelo durante o treinamento (ex: pesos de uma rede neural, coeficientes de uma regressão).
- Hiperparâmetros: São definidos antes do treinamento e influenciam a forma como o modelo aprende (ex: taxa de aprendizado, número de árvores em um Random Forest, número de vizinhos em um KNN).
A otimização de hiperparâmetros visa encontrar a melhor combinação para maximizar a performance do modelo em dados nunca vistos.
Métodos de Otimização de Hiperparâmetros
1. Grid Search: A Busca Exaustiva
Grid Search é uma das técnicas mais simples e amplamente utilizadas para otimização de hiperparâmetros. A ideia por trás do Grid Search é bastante direta: você define uma grade de valores possíveis para cada hiperparâmetro e o algoritmo testa todas as combinações possíveis desses valores.
Como funciona?
- Define-se um conjunto de valores para cada hiperparâmetro.
- O algoritmo treina o modelo para cada combinação possível de valores.
- Avalia-se o desempenho do modelo para cada combinação.
- Seleciona-se a combinação que produz o melhor desempenho.
Vantagens:
- Simples de implementar e entender.
- Garante que todas as combinações sejam testadas.
Desvantagens:
- Pode ser computacionalmente caro, especialmente com um grande número de hiperparâmetros e valores.
- Ineficiente em espaços de busca grandes, pois não prioriza combinações mais promissoras.
Aplicação prática:
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
# Carregando o dataset iris
iris = load_iris()
X, y = iris.data, iris.target
# Separação dos dados entre treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Definição do grid de parametros
param_grid = {'n_estimators': [10, 50, 100], 'max_depth': [5, 10, 20]}
# Criação do modelo RandomForestClassifier
model = RandomForestClassifier(random_state=42) #Setting random state for reproducibility
# Creação do objeto GridSearchCV
grid_search = GridSearchCV(model, param_grid, cv=5, scoring='accuracy')
# Fit do objeto GridSearchCV nos dados de treino
grid_search.fit(X_train, y_train)
# Impressão dos melhores parametros
print("Melhores parametros:", grid_search.best_params_)
# Avalia o melhor modelo nos dados de teste
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Acurácia do melhor modelo nos dados de teste: {accuracy}")
Melhores parametros: {'max_depth': 5, 'n_estimators': 100}
Acurácia do melhor modelo nos dados de teste: 1.02. Random Search: A Busca Aleatória
Random Search é uma alternativa ao Grid Search que, em vez de testar todas as combinações possíveis, seleciona aleatoriamente um conjunto de combinações para testar. A ideia é que, em muitos casos, uma amostra aleatória pode encontrar uma combinação de hiperparâmetros que performa tão bem quanto a melhor combinação encontrada pelo Grid Search, mas com muito menos esforço computacional.
Como funciona?
- Define-se uma distribuição de valores para cada hiperparâmetro.
- O algoritmo seleciona aleatoriamente um conjunto de combinações de valores.
- Treina-se o modelo para cada combinação selecionada.
- Avalia-se o desempenho e seleciona-se a melhor combinação.
Vantagens:
- Menos custoso computacionalmente em comparação com o Grid Search.
- Pode ser mais eficiente em espaços de busca grandes.
Desvantagens:
- Não garante que a melhor combinação seja encontrada.
- Pode exigir mais iterações para encontrar uma solução satisfatória.
Aplicação prática:
from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
import numpy as np
# Carregando o dataset iris
iris = load_iris()
X, y = iris.data, iris.target
# Separação dos dados entre treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Definição do espaço de parâmetros para a busca aleatória
param_dist = {'n_estimators': np.arange(10, 200, 10), 'max_depth': [None, 10, 20, 30]}
# Criação do modelo RandomForestClassifier
model = RandomForestClassifier(random_state=42)
# Criação do objeto RandomizedSearchCV
random_search = RandomizedSearchCV(model, param_distributions=param_dist, n_iter=10, cv=5, scoring='accuracy', random_state=42)
# Fit do objeto RandomizedSearchCV nos dados de treino
random_search.fit(X_train, y_train)
# Impressão dos melhores parâmetros
print("Melhores parâmetros:", random_search.best_params_)
# Avalia o melhor modelo nos dados de teste
best_model = random_search.best_estimator_
y_pred = best_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Acurácia do melhor modelo nos dados de teste: {accuracy}")
Melhores parâmetros: {'n_estimators': 170, 'max_depth': 10}
Acurácia do melhor modelo nos dados de teste: 1.03. Bayesian Optimization: A Busca Inteligente
Bayesian Optimization é uma técnica mais sofisticada que utiliza métodos probabilísticos para encontrar os melhores hiperparâmetros. Diferente do Grid Search e do Random Search, que não utilizam informações das iterações anteriores, o Bayesian Optimization constrói um modelo probabilístico (geralmente um Processo Gaussiano) da função de desempenho do modelo em relação aos hiperparâmetros. Ele usa esse modelo para prever quais combinações de hiperparâmetros têm maior probabilidade de melhorar o desempenho e foca em testar essas combinações.
Como funciona?
- Define-se uma distribuição de valores para cada hiperparâmetro.
- O algoritmo constrói um modelo probabilístico da função de desempenho.
- Usa-se o modelo para prever as combinações mais promissoras.
- Treina-se o modelo com essas combinações e atualiza-se o modelo probabilístico.
- Repete-se o processo até encontrar uma combinação satisfatória.
Vantagens:
- Mais eficiente em espaços de busca grandes.
- Requer menos iterações para encontrar uma solução ótima.
- Aproveita informações das iterações anteriores para guiar a busca.
Desvantagens:
- Mais complexo de implementar.
- Pode ser computacionalmente caro para construir e atualizar o modelo probabilístico.
Aplicação prática:
import optuna
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
# Carregando o dataset iris
iris = load_iris()
X, y = iris.data, iris.target
# Separação dos dados entre treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
def objective(trial):
# Definição do espaço de hiperparâmetros
n_estimators = trial.suggest_int('n_estimators', 10, 200)
max_depth = trial.suggest_int('max_depth', 5, 30, log=True) # log=True para valores mais próximos a 1
# Criação do modelo
model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, random_state=42)
# Treinamento do modelo
model.fit(X_train, y_train)
# Predição nos dados de teste
y_pred = model.predict(X_test)
# Retorna a acurácia como objetivo
return accuracy_score(y_test, y_pred)
# Criação do estudo Optuna
study = optuna.create_study(direction='maximize') # Maximizar a acurácia
# Otimização
study.optimize(objective, n_trials=100) # número de tentativas
# Impressão dos melhores hiperparâmetros
print("Melhores hiperparâmetros:", study.best_params)
print("Melhor acurácia:", study.best_value)
# Treinamento do modelo com os melhores hiperparâmetros encontrados
best_model = RandomForestClassifier(**study.best_params, random_state=42)
best_model.fit(X_train, y_train)
y_pred = best_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Acurácia do melhor modelo nos dados de teste: {accuracy}")
[I 2025-02-24 18:57:08,841] Trial 97 finished with value: 1.0 and parameters: {'n_estimators': 21, 'max_depth': 17}. Best is trial 0 with value: 1.0.
[I 2025-02-24 18:57:09,040] Trial 98 finished with value: 1.0 and parameters: {'n_estimators': 186, 'max_depth': 5}. Best is trial 0 with value: 1.0.
[I 2025-02-24 18:57:09,222] Trial 99 finished with value: 1.0 and parameters: {'n_estimators': 161, 'max_depth': 28}. Best is trial 0 with value: 1.0.
Melhores hiperparâmetros: {'n_estimators': 182, 'max_depth': 7}
Melhor acurácia: 1.0
Acurácia do melhor modelo nos dados de teste: 1.0Qual técnica escolher?
A escolha da técnica de otimização de hiperparâmetros depende do problema em questão, dos recursos computacionais disponíveis e do tempo que você pode dedicar ao processo. Aqui estão algumas diretrizes:
- Grid Search: Ideal para espaços de busca pequenos e quando você tem recursos computacionais suficientes para testar todas as combinações.
- Random Search: Uma boa opção quando o espaço de busca é grande e você deseja reduzir o tempo de computação.
- Bayesian Optimization: Recomendado para problemas complexos com espaços de busca grandes, onde a eficiência na busca é crucial.
Conclusão
A otimização de hiperparâmetros é uma etapa essencial no desenvolvimento de modelos de machine learning. Grid Search, Random Search e Bayesian Optimization são técnicas poderosas que podem ajudá-lo a encontrar os melhores hiperparâmetros para o seu modelo. Cada uma tem suas vantagens e desvantagens, e a escolha da técnica certa pode fazer toda a diferença no desempenho do seu modelo.
Experimente essas técnicas em seus próximos projetos e veja como elas podem melhorar a performance dos seus modelos. E lembre-se: a otimização de hiperparâmetros é tanto uma ciência quanto uma arte, e a prática constante é a chave para dominá-la.
Se você gostou deste post e quer aprender mais sobre machine learning e otimização de modelos, não deixe de acompanhar nosso blog para mais conteúdos como este!
Recomendação de livros
- Mãos à obra aprendizado de máquina com Scikit-Learn, Keras & TensorFlow: conceitos, ferramentas e técnicas para a construção de sistemas inteligentes.
- Python para análise de dados
- Estatística Prática Para Cientistas de Dados: 50 Conceitos Essenciais
- An Introduction to Statistical Learning (Python e R)
