Bagging (Agregação por Bootstrap)

Visão geral

Agregação por bootstrap (bagging) (abreviação de agregação por bootstrap (bootstrap aggregating)) é um método de conjunto (ensemble) que melhora o desempenho preditivo ao treinar muitas versões do mesmo modelo base (base model) em diferentes conjuntos de dados reamostrados por bootstrap (bootstrap-resampled datasets) e, em seguida, agregar (aggregating) suas previsões (tipicamente por média em regressão ou votação majoritária em classificação).

A agregação por bootstrap é principalmente uma técnica de redução de variância (variance reduction). Ela é especialmente eficaz para aprendizes instáveis, de alta variância (unstable, high-variance learners), como Árvores de Decisão (Decision Trees), em que pequenas mudanças nos dados de treino podem levar a modelos ajustados visivelmente diferentes. Ao fazer a média entre muitos desses modelos, a agregação por bootstrap produz um preditor tipicamente mais estável e que generaliza melhor.

A agregação por bootstrap é uma das técnicas fundamentais em Aprendizado por Conjuntos (Ensemble Learning) e é um ingrediente-chave em Florestas Aleatórias (Random Forests).

A ideia central: reamostragem por bootstrap

O que “bootstrap” significa aqui

Dado um conjunto de treino de tamanho (n), uma amostra bootstrap (bootstrap sample) é criada ao amostrar (n) exemplos com reposição (with replacement) a partir do conjunto de treino.

Consequências importantes:

Cada amostra bootstrap contém duplicatas.
Em média, cada amostra bootstrap contém cerca de 63,2% de exemplos únicos do treino.
- Motivo: a probabilidade de um exemplo específico nunca ser selecionado é ((1 - 1/n)^n \approx e^{-1} \approx 0.368).
- Então, cerca de 36,8% dos exemplos de treino ficam fora do saco (out-of-bag, OOB) para aquela amostra bootstrap (mais sobre isso em Avaliação fora do saco).

Esboço do algoritmo

Para (M) modelos base:

Para (m = 1 \ldots M):
- Extraia um conjunto bootstrap (D_m) amostrando dos dados de treino com reposição.
- Treine um aprendiz base (base learner) (f_m) em (D_m).
Agregue as previsões:
- Regressão: (\hat{y}(x) = \frac{1}{M}\sum_{m=1}^M f_m(x))
- Classificação:
  - Votação majoritária (majority vote): (\hat{y}(x) = \text{mode}{f_1(x), \ldots, f_M(x)})
  - Frequentemente melhor: fazer a média das probabilidades previstas e então tomar o argmax.

É por isso que a agregação por bootstrap às vezes é descrita como “treinar muitos modelos em versões perturbadas do conjunto de dados e, em seguida, fazer a média”.

Como a agregação por bootstrap combina previsões

Regressão: média

Para regressão, a agregação por bootstrap tipicamente usa a média das previsões:

[ \hat{y}(x) = \frac{1}{M}\sum_{m=1}^M f_m(x) ]

A média é poderosa porque erros independentes (ou fracamente correlacionados) tendem a se cancelar.

Classificação: votação ou média de probabilidades

Para classificação, há duas abordagens comuns:

Votação rígida (hard voting) (votação majoritária): cada modelo base produz um rótulo de classe.
Votação suave (soft voting) (média de probabilidades): cada modelo base produz probabilidades de classe; essas são promediadas.

A votação suave costuma ser preferida porque usa mais informação e tende a ser melhor calibrada — embora alguns conjuntos ainda precisem de calibração explícita via métodos discutidos em Calibração de Modelos (Model Calibration) (se a sua wiki incluir isso).

Por que a agregação por bootstrap funciona: redução de variância (teoria)

O principal benefício da agregação por bootstrap é reduzir a variância enquanto mantém o viés (bias) aproximadamente semelhante ao do aprendiz base. Isso se conecta diretamente ao Trade-off Viés–Variância (Bias-Variance Tradeoff).

Intuição: modelos instáveis se beneficiam mais

Um modelo é “instável” se pequenas mudanças nos dados de treino causam grandes mudanças no modelo ajustado. Exemplos clássicos incluem:

Árvores de decisão profundas
Polinômios de alto grau
Algumas redes neurais (dependendo da aleatoriedade do treino e do tamanho dos dados)

Para tais modelos, cada amostra bootstrap produz um ajuste significativamente diferente. Fazer a média desses ajustes reduz a sensibilidade a qualquer amostra em particular.

Uma aproximação útil de variância (correlação importa)

Suponha que cada modelo base tenha variância de predição (\sigma^2), e que a correlação média entre as predições dos modelos seja (\rho). Então a variância do preditor médio é aproximadamente:

[ \text{Var}(\bar{f}) \approx \rho\sigma^2 + \frac{(1-\rho)\sigma^2}{M} ]

Principais conclusões:

Aumentar o número de estimadores (M) ajuda mais quando os modelos não são muito correlacionados.
Se (\rho) for alto (modelos muito similares), a agregação por bootstrap traz ganhos limitados.
A agregação por bootstrap funciona ao:
1. tornar os modelos diferentes (via amostragem bootstrap),
2. e então fazer a média para cancelar variância.

Isso também explica por que métodos que reduzem ainda mais a correlação — como a subamostragem de atributos (feature subsampling) em Florestas Aleatórias — frequentemente melhoram em relação à agregação por bootstrap simples.

Quando a agregação por bootstrap ajuda (e quando não ajuda)

A agregação por bootstrap ajuda quando

O aprendiz base é de alta variância / instável:
- Árvores de decisão profundas são o exemplo padrão.
Você tem dados suficientes para que a reamostragem crie conjuntos de treino significativamente diferentes.
Você pode arcar com computação extra: treinar (M) modelos custa (aproximadamente) (M) vezes o custo de um modelo (embora paralelize bem).

Ganhos típicos:

Melhor generalização (menor erro de teste)
Previsões mais estáveis (menor sensibilidade a ruído)
Robustez a peculiaridades do conjunto de treino

A agregação por bootstrap ajuda menos (ou pode não ajudar) quando

O aprendiz base já é de baixa variância / estável, como:
- Modelos lineares regularizados (regressão ridge/logística com regularização forte)
- kNN com k grande (frequentemente relativamente estável)
O modelo tem alto viés e subajusta (underfitting):
- A agregação por bootstrap não corrige fundamentalmente o subajuste; ela principalmente reduz variância.
Os dados são extremamente pequenos:
- Amostras bootstrap ficam muito similares; melhorias podem ser marginais ou ruidosas.

Principais hiperparâmetros e escolhas práticas

A agregação por bootstrap tem alguns controles de alto impacto. Muitas bibliotecas expõem isso com nomes como n_estimators, max_samples, bootstrap e, às vezes, max_features.

Número de estimadores (`n_estimators`)

Mais estimadores geralmente melhora o desempenho, mas com retornos decrescentes.
Orientação prática:
- Comece com 100 para árvores em muitas tarefas tabulares.
- Aumente para 300–1000 se:
  - o desempenho ainda estiver melhorando,
  - você precisar de menor variância,
  - o orçamento de computação permitir.
Use curvas de validação (validation curves) ou estimativas OOB para ver onde os ganhos estabilizam (veja Ajuste de Hiperparâmetros (Hyperparameter Tuning)).

Taxa de amostragem (`max_samples`)

Enquanto a agregação por bootstrap “clássica” amostra (n) pontos com reposição, muitas implementações permitem escolher uma fração:

max_samples = 1.0 (padrão em muitas ferramentas): amostra (n) pontos com reposição.
Valores menores (ex.: 0.5–0.9) podem:
- aumentar a diversidade entre modelos (potencialmente reduzindo a correlação),
- reduzir o tempo de treino por estimador,
- mas podem aumentar o viés se cada modelo vir poucos dados.

Não existe um melhor valor universal; padrões comuns são razoáveis, mas, para conjuntos grandes, max_samples < 1.0 pode ser um bom compromisso.

Amostragem com ou sem reposição (`bootstrap`)

Com reposição (bootstrap): agregação por bootstrap padrão.
Sem reposição às vezes é chamado de colagem (pasting).
- Pode funcionar bem quando você quer diversidade, mas prefere não repetir exemplos.
- Não é “bootstrap” no sentido estatístico estrito, mas frequentemente é oferecido como alternativa prática.

Escolha do estimador base

A agregação por bootstrap é um meta-algoritmo (meta-algorithm); você pode aplicá-la a quase qualquer aprendiz. Mas a escolha do estimador base determina se vale a pena.

Escolhas comuns:

Árvores de decisão: a mais comum, muitas vezes com árvores profundas (alta variância).
Redes neurais: às vezes usadas historicamente com bagging; hoje, outros métodos de regularização são frequentemente usados, mas a agregação por bootstrap ainda pode ajudar em certos cenários tabulares.
Pipelines instáveis: por exemplo, modelos sensíveis à seleção de atributos ou à aleatoriedade do treino.

Regra prática: se um único modelo já é estável e bem regularizado, a agregação por bootstrap pode trazer pouca melhoria.

Subamostragem de atributos (`max_features`) (opcional, mas importante conceitualmente)

Algumas implementações de agregação por bootstrap permitem amostrar atributos (features) além das linhas. Isso decorrelaciona ainda mais os modelos.

Se você fizer isso com árvores (especialmente selecionando atributos a cada divisão), você fica muito próximo de uma abordagem no estilo de Florestas Aleatórias.
Amostragem de linhas + amostragem de atributos costuma ser mais forte do que apenas amostragem de linhas porque reduz (\rho) (correlação).

Avaliação fora do saco

A avaliação fora do saco (OOB) é uma técnica de validação embutida viabilizada pela amostragem bootstrap.

Como a pontuação OOB funciona

Para cada exemplo de treino (i):

Identifique quais estimadores não incluíram (i) em sua amostra bootstrap (isto é, em quais (i) ficou fora do saco).
Prediga (i) usando somente esses estimadores.
Agregue essas previsões para obter uma predição OOB para (i).

Calcule métricas de desempenho (acurácia, RMSE etc.) usando as predições OOB no conjunto de treino.

Por que OOB é útil

Não exige conjunto de validação separado, então você pode treinar com todos os dados.
Frequentemente fornece uma estimativa semelhante à validação cruzada, especialmente quando (M) é grande.
Eficiente: você obtém avaliação “de graça” durante o treino.

Ressalvas

OOB não é idêntico à Validação Cruzada (Cross-Validation) k-fold:
- pode ser mais ruidosa para conjuntos pequenos ou n_estimators pequeno,
- e sua confiabilidade varia com o algoritmo de aprendizado.
Se seu pré-processamento usa estatísticas globais do conjunto (por exemplo, escalonamento calculado em todos os dados), você deve usar um pipeline adequado para evitar vazamento (veja Vazamento de Dados (Data Leakage), se disponível).

Relação com florestas aleatórias (e outros ensembles de árvores)

Agregação por bootstrap vs. Florestas Aleatórias

Uma floresta aleatória (random forest) é essencialmente:

Agregação por bootstrap de árvores de decisão (amostras bootstrap de linhas),
mais seleção aleatória de atributos em cada divisão (ou por árvore), o que:
- reduz a correlação entre árvores,
- melhora a redução de variância,
- tipicamente produz melhor acurácia do que a agregação por bootstrap simples de árvores totalmente crescidas.

Assim, você pode pensar em florestas aleatórias como “agregação por bootstrap + aleatoriedade extra na seleção de atributos”.

Extra Trees (Extremely Randomized Trees)

Outro método relacionado é Extra Trees, que aumenta ainda mais a aleatoriedade ao escolher limiares de divisão aleatoriamente. Como florestas aleatórias, ele busca reduzir correlação e variância. (Se a sua wiki tiver isso, link como Árvores Extras (Extra Trees).)

Onde a agregação por bootstrap ainda se encaixa

A agregação por bootstrap continua útil quando:

você quer um ensemble em torno de um estimador que não é árvore,
você quer a simplicidade conceitual de “mesmo modelo, diferentes bootstraps”,
você quer avaliação OOB sem um conjunto de validação separado.

Para padrões mais amplos como empilhamento (stacking) e mistura (blending), veja Estratégias de Ensemble (Ensembling Strategies).

Exemplos práticos (scikit-learn)

Abaixo há exemplos usando APIs no estilo scikit-learn. Os mesmos princípios se aplicam em outros ecossistemas.

Exemplo 1: Agregação por bootstrap de uma árvore de decisão para classificação com pontuação OOB

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.metrics import accuracy_score

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y
)

base_tree = DecisionTreeClassifier(
    random_state=42,
    # deep trees are high-variance, so bagging often helps
    max_depth=None,
    min_samples_leaf=1
)

bagger = BaggingClassifier(
    estimator=base_tree,
    n_estimators=300,
    max_samples=1.0,      # bootstrap sample size = n
    bootstrap=True,       # sample rows with replacement
    oob_score=True,       # enable out-of-bag evaluation
    n_jobs=-1,
    random_state=42
)

bagger.fit(X_train, y_train)

print("OOB accuracy:", bagger.oob_score_)
print("Test accuracy:", accuracy_score(y_test, bagger.predict(X_test)))

O que observar:

O ensemble com bagging geralmente supera uma única árvore profunda em dados de teste.
A acurácia OOB é uma verificação rápida de sanidade e pode guiar o ajuste de n_estimators e max_samples.

Exemplo 2: Agregação por bootstrap para regressão (redução de variância)

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import BaggingRegressor
from sklearn.metrics import mean_squared_error
import numpy as np

X, y = fetch_california_housing(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

base_tree = DecisionTreeRegressor(random_state=42)

bagger = BaggingRegressor(
    estimator=base_tree,
    n_estimators=300,
    max_samples=0.8,   # try < 1.0 to increase diversity and speed
    bootstrap=True,
    n_jobs=-1,
    random_state=42
)

bagger.fit(X_train, y_train)
pred = bagger.predict(X_test)

rmse = np.sqrt(mean_squared_error(y_test, pred))
print("Test RMSE:", rmse)

Nota prática: para regressão baseada em árvores, a agregação por bootstrap frequentemente reduz o comportamento “espinhoso”, sobreajustado, de árvores individuais.

Exemplo 3: Agregação por bootstrap de um modelo “estável” (por que os ganhos podem ser pequenos)

Se você aplicar bagging a um modelo linear fortemente regularizado, frequentemente quase nada muda, porque o modelo já é estável.

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import BaggingClassifier

base_lr = LogisticRegression(max_iter=2000, C=1.0)

bagged_lr = BaggingClassifier(
    estimator=base_lr,
    n_estimators=100,
    bootstrap=True,
    n_jobs=-1,
    random_state=42
)

Isso ainda pode ajudar em alguns casos (por exemplo, rótulos ruidosos), mas não é onde a agregação por bootstrap tipicamente mais se destaca.

Orientações práticas e armadilhas

Use pipelines para evitar vazamento

Se você escalona, imputa, codifica ou seleciona atributos, faça isso dentro de um pipeline para que cada estimador aprenda o pré-processamento a partir de sua amostra bootstrap corretamente.

Veja: Pipelines (se disponível), Vazamento de Dados.

Lide com desbalanceamento de classes com cuidado

A agregação por bootstrap não corrige automaticamente desbalanceamento. Considere:

estimadores base com peso por classe,
estratégias de reamostragem (SMOTE, undersampling) aplicadas dentro dos folds/bootstraps de treino,
métricas além de acurácia (AUC, F1).

Não ajuste demais `n_estimators` no conjunto de teste

Use estimativas OOB, um conjunto de validação ou Validação Cruzada. Para ajuste sistemático, veja Ajuste de Hiperparâmetros.

Interpretabilidade

Um ensemble com bagging é mais difícil de interpretar do que um único modelo. Você pode usar:

importância por permutação (permutation importance),
dependência parcial (partial dependence),
métodos do tipo SHAP (SHAP-like methods) (se houver suporte).

(Se a sua wiki incluir isso, link: Interpretabilidade de Modelos (Model Interpretability).)

Custos de computação e memória

O custo de treino cresce com n_estimators.
Use paralelismo (n_jobs=-1 no scikit-learn).
Considere parar quando o desempenho OOB/validação estabilizar.

Resumo

A agregação por bootstrap (bagging) é um método de conjunto simples e poderoso:

Treine muitos modelos base em conjuntos reamostrados por bootstrap.
Agregue previsões via média (regressão) ou votação/média de probabilidades (classificação).
Seu principal efeito é a redução de variância, melhorando a generalização para aprendizes instáveis.
Os principais hiperparâmetros incluem:
- número de estimadores (n_estimators),
- taxa de amostragem (max_samples),
- se a amostragem usa reposição (bootstrap),
- além da escolha do estimador base.
A avaliação fora do saco fornece uma estimativa interna eficiente de desempenho sem dados de validação separados.
Florestas Aleatórias podem ser vistas como agregação por bootstrap de árvores de decisão mais aleatoriedade ao nível de atributos para reduzir ainda mais a correlação entre árvores.

Para padrões de ensemble mais amplos além de bagging — como stacking e blending — veja Estratégias de Ensemble.