0Pricing
Learn AI with Python · Aula

Gradient Boosting: GBM e XGBoost

Boosting em comparação com bagging, GradientBoostingClassifier, XGBClassifier e parada antecipada.

Gradient Boosting: GBM e XGBoost é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.

Reforço versus agregação

Agregação treina árvores em paralelo e calcula a média entre elas. Reforço treina árvores sequencialmente, em que cada nova árvore corrige os erros das anteriores.

O reforço reduz o viés e muitas vezes alcança maior acurácia do que a agregação em dados estruturados.

Aprendizes fracos sequenciais

O reforço por gradiente cria um conjunto de árvores rasas (aprendizes fracos). Cada árvore se ajusta aos resíduos (gradientes da perda) deixados pelo conjunto atual.

Adicionar muitas pequenas correções cria um modelo geral forte.

GradientBoostingClassifier

O Scikit-learn fornece GradientBoostingClassifier. Os principais parâmetros são n_estimators (número de árvores), learning_rate (redução da escala) e max_depth (tamanho da árvore).

from sklearn.ensemble import GradientBoostingClassifier

gbm = GradientBoostingClassifier(
    n_estimators=200,
    learning_rate=0.1,
    max_depth=3,
    random_state=0,
)
gbm.fit(Xtr, ytr)
print(gbm.score(Xte, yte))

O compromisso da taxa de aprendizado

learning_rate dimensiona a contribuição de cada árvore. Uma taxa de aprendizado menor exige mais árvores, mas geralmente generaliza melhor.

Uma estratégia comum é definir uma taxa de aprendizado baixa (por exemplo, 0,05) e muitos estimadores, e depois usar a parada antecipada.

from sklearn.ensemble import GradientBoostingClassifier

gbm = GradientBoostingClassifier(
    n_estimators=1000,
    learning_rate=0.05,
    max_depth=3,
)

Por que max_depth permanece pequeno

No reforço, cada árvore é um aprendiz fraco, portanto max_depth geralmente fica entre 3 e 6. Árvores profundas superajustariam os resíduos rapidamente. O conjunto ganha força com muitas árvores rasas, não com algumas árvores profundas.

Introdução ao XGBoost

XGBoost é uma biblioteca otimizada de reforço por gradiente: mais rápida, regularizada e com tratamento integrado de valores ausentes. Ela tem desempenho de destaque em competições de aprendizado de máquina com dados tabulares.

from xgboost import XGBClassifier

model = XGBClassifier(
    n_estimators=300,
    learning_rate=0.1,
    max_depth=4,
    random_state=0,
)
model.fit(Xtr, ytr)
print(model.score(Xte, yte))

Principais parâmetros do XGBoost

Os principais controles são semelhantes aos do GBM:

  • n_estimators número de rodadas de reforço
  • learning_rate redução da escala por rodada
  • max_depth profundidade da árvore
  • subsample e colsample_bytree adicionam aleatoriedade para regularização
from xgboost import XGBClassifier

model = XGBClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=4,
    subsample=0.8,
    colsample_bytree=0.8,
)

Regularização no XGBoost

O XGBoost adiciona penalidades L1 (reg_alpha) e L2 (reg_lambda), além de gamma (redução mínima da perda para dividir). Esses recursos controlam a complexidade e reduzem o sobreajuste além do que o GBM simples oferece.

from xgboost import XGBClassifier

model = XGBClassifier(
    reg_alpha=0.1,
    reg_lambda=1.0,
    gamma=0.1,
)

Parada antecipada

early_stopping_rounds interrompe o treinamento quando a métrica de validação deixa de melhorar por N rodadas. Isso encontra automaticamente o número adequado de árvores e evita o sobreajuste.

from xgboost import XGBClassifier

model = XGBClassifier(
    n_estimators=2000,
    learning_rate=0.05,
    early_stopping_rounds=50,
    eval_metric="logloss",
)
model.fit(Xtr, ytr, eval_set=[(Xte, yte)], verbose=False)
print("Best iteration:", model.best_iteration)

Lendo a importância das características

O XGBoost disponibiliza feature_importances_ e um get_booster().get_score() mais completo, com tipos de importância como ganho e peso. O ganho indica quanto uma característica melhorou a perda.

model = XGBClassifier(n_estimators=200).fit(Xtr, ytr)
print(model.feature_importances_)

booster = model.get_booster()
print(booster.get_score(importance_type="gain"))

Quando recorrer ao reforço

O reforço por gradiente muitas vezes supera as florestas aleatórias em dados tabulares quando é bem ajustado. O custo é uma maior sensibilidade aos hiperparâmetros e um treinamento sequencial mais lento. Comece com os valores padrão do XGBoost, depois ajuste learning_rate, max_depth e use a parada antecipada.

Verificação rápida

Verifique seus conhecimentos sobre reforço.

Recapitulação

Recapitulação: O reforço treina árvores sequencialmente, e cada uma corrige erros anteriores. Ajuste n_estimators, learning_rate (taxa baixa + muitas árvores) e um max_depth pequeno. O XGBoost adiciona regularização (reg_alpha, reg_lambda, gamma) e early_stopping_rounds para escolher automaticamente a quantidade ideal de árvores.

Perguntas Frequentes

A aula “Gradient Boosting: GBM e XGBoost” é grátis?

Sim — o texto completo de “Gradient Boosting: GBM e XGBoost” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.

O que vou aprender em “Gradient Boosting: GBM e XGBoost”?

Boosting em comparação com bagging, GradientBoostingClassifier, XGBClassifier e parada antecipada. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn AI with Python?

Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Gradient Boosting: GBM e XGBoost”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn AI with Python?

Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Árvores de decisão: teoria e implementação
  2. Florestas aleatórias e bagging
  3. Gradient Boosting: GBM e XGBoost
  4. LightGBM e CatBoost
← Voltar para Learn AI with Python