Se você está se interessando pelo aprendizado de máquina, é provável que você tenha ouvido sussurros de um modelo que domina as competições de kaggle e lida com dados tabulares como um chefe: sim, estamos falando sobre Xgboost.
Mas o que torna o XGBoost tão poderoso? E, mais importante, como você realmente o usa sem se perder na selva de parâmetros e jargão?
Este é o seu guia prático e amigável ao ser humano para XGBoost-da instalação à otimização e tudo mais.
Por que todo mundo ama XGBoost (incluindo Kaggle Grandmasters)
XGBOOST significa Aumentado de gradiente extremo. No seu coração, é uma implementação eficiente e escalável de árvores de decisão impulsionadas por gradientes. O que isso significa em inglês simples: constrói modelos aprendendo com seus erros, iterativamente, como uma criança tentando aperfeiçoar um avião de papel.
Mas, diferentemente dos modelos GBDT tradicionais, o XGBoost é altamente otimizado para velocidade e precisão. Ele suporta paralelização, lida com os dados ausentes de graça e é testado em batalhas em grandes conjuntos de dados.
Introdução: instalação e configuração
Abra o seu terminal (ou Jupyter Notebook) e instale o pacote:
pip install xgboost
Para verificar se instalou corretamente:
import xgboost as xgb
print(xgb.__version__)
Vamos treinar um modelo (na íris, o “Hello World” do ML)
Usaremos o famoso conjunto de dados da IRIS – uma tarefa de classificação clássica com 3 tipos de flores. Veja como preparar os dados:
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
Encontrar DMatrix: Arma secreta do XGBOOST
Antes de alimentar os dados do modelo, envolva -os no formato otimizado do XGBOOST:
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test)
Vamos treinar
params = {
'objective': 'multi:softmax',
'num_class': 3,
'max_depth': 3,
'eta': 0.2,
'seed': 42
}
model = xgb.train(params, dtrain, num_boost_round=10)
preds = model.predict(dtest)
Avalie o desempenho:
from sklearn.metrics import accuracy_score
print("Accuracy:", accuracy_score(y_test, preds))
Você deve ver algo em torno de ~ 95%+ precisão pronta para uso. Nada mal.
Ajustando a máquina: GridSearch em ação
Não vamos fingir que as configurações padrão são boas o suficiente para um trabalho real. Veja como pesquisar em grade para um modelo melhor:
from sklearn.model_selection import GridSearchCV
from xgboost import XGBClassifier
param_grid = {
'max_depth': [3, 5],
'learning_rate': [0.1, 0.3],
'n_estimators': [50, 100]
}
grid = GridSearchCV(XGBClassifier(use_label_encoder=False), param_grid, scoring='accuracy', cv=3)
grid.fit(X_train, y_train)
print("Best params:", grid.best_params_)
Importância do recurso: quem mais importa?
Quer espiar dentro da caixa preta?
import matplotlib.pyplot as plt
xgb.plot_importance(model)
plt.show()
Você verá quais recursos o modelo se apoiou na maioria. É simples, mas surpreendentemente perspicaz.
Shap: Explique previsões como um profissional
Instale o Shap se você quiser se tornar nerd sobre a explicação do modelo:
pip install shap
Então:
import shap
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test)
Agora você não é apenas modelos de treinamento, você está compreendê -los.
Bônus: XGBoost para regressão e tarefas binárias
Classificação não é tudo o XGBOOST faz. Quer prever os preços das casas?
params = {'objective': 'reg:squarederror', 'eta': 0.1}
Para classificação binária?
params = {'objective': 'binary:logistic', 'eta': 0.3}
O restante do processo é quase idêntico.
Apêndice Avançado: Treinamento Distribuído com XGBoost
Quando seu conjunto de dados começa a atingir milhões de linhas ou você deseja espremer cada grama de desempenho, é hora de se distribuir.
Opção 1: Treinamento Multi-GPU
O XGBOOST possui suporte de GPU integrado. Basta definir tree_method para gpu_hist:
params = {
'tree_method': 'gpu_hist',
'predictor': 'gpu_predictor',
'objective': 'binary:logistic',
'max_depth': 4,
'eta': 0.3
}
Você precisará instalar a versão habilitada para GPU do XGBoost e garantir que o CUDA esteja configurado.
Opção 2: CPU/GPU distribuído com DASK
O DASK é uma ótima maneira de escalar XGBoost entre os clusters (local ou nuvem).
from dask.distributed import Client
from dask_cuda import LocalCUDACluster
from xgboost.dask import DaskDMatrix, train
client = Client(LocalCUDACluster())
# Assume X_dask and y_dask are Dask arrays or DataFrames
dtrain = DaskDMatrix(client, X_dask, y_dask)
params = {"objective": "reg:squarederror", "tree_method": "gpu_hist"}
output = train(client, params, dtrain, num_boost_round=100)
Dask lida com o levantamento pesado de dividir dados em pedaços e agendar em várias GPUs ou CPUs.
Opção 3: Use Spark com XGBOOST4J
Para sistemas em escala corporativa em execução do Apache Spark, o XGBoost oferece uma solução compatível com JVM: Xgboost4j. Ele se integra diretamente aos pipelines Spark ML e pode lidar com grandes dados com alta taxa de transferência.
A configuração é um pouco mais complexa, mas vale a pena se você já está executando a infraestrutura do Spark.
Pensamentos finais: você deve usar o XGBoost?
Sim – se você tiver dados estruturados e precisar de algo rápido, poderoso e flexível. O XGBOOST não é uma bala de prata, mas está perto.
Este guia mal arranha a superfície. Você pode enlouquecer com regularização avançada, funções de perda personalizada, parada precoce e até treinamento de GPU distribuído. Mas, para a maioria dos casos de uso, dominar o que abordamos aqui o coloca à frente de 90% dos usuários.
