Você treina um modelo XGBoost, ele acerta 85% dos casos. Depois testa uma Random Forest, que chega a 82%. Combinar os dois parece óbvio, mas como fazer isso de forma inteligente? É aí que entram stacking e blending — duas técnicas de ensemble que, em 2025, reduziram o erro de generalização em 12% a 18% nos benchmarks do Kaggle (Kaggle Blog, 2025). Em 2026, elas se consolidaram como ferramentas essenciais para qualquer competição ou projeto de classificação.

Mas qual escolher? Stacking ou blending? A diferença é sutil, mas o impacto no resultado pode ser brutal. Neste guia prático, você vai entender o funcionamento de cada uma, ver implementações em Python com scikit-learn e, no final, saber exatamente quando usar cada técnica.

O Problema que o Ensemble Resolve

Modelos individuais têm vieses. Uma árvore de decisão adora overfitting. Uma regressão logística pode ser simples demais para capturar interações complexas. Combinar múltiplos modelos — o princípio do ensemble — mitiga esses pontos cegos.

A grande sacada do ensemble methods é tratar o modelo base como um "especialista". Stacking e blending vão além da simples votação (hard voting) ou média de probabilidades (soft voting). Eles treinam um meta-learner para aprender o melhor jeito de combinar as previsões dos modelos base.

"Ensemble methods, como stacking, permitem que o modelo aprenda os pontos fortes e fracos de cada preditor base, resultando em ganhos consistentes de performance, especialmente em datasets com ruído." — Trecho do benchmark de 2025 sobre ensemble methods (Kaggle Blog).

Em um teste recente no dataset UCI Adult, um stacking simples com meta-learner leve (Regressão Logística) superou um XGBoost puro em 5% de acurácia (UCI Machine Learning Repository). Não é um número absurdo, mas em problemas de crédito ou diagnóstico médico, 5% pode significar milhões de reais ou vidas salvas.

Stacking: O Mestre que Aprende com os Especialistas

Como Funciona na Prática

Stacking (stacked generalization) funciona em duas camadas. Primeiro, você treina vários modelos base (nível 0) no dataset de treino completo. Depois, usa as previsões desses modelos como features para treinar um meta-learner (nível 1).

O pulo do gato está na validação. Para evitar vazamento de dados (data leakage), as previsões dos modelos base não podem ser feitas no mesmo dataset em que eles foram treinados. A solução clássica é usar k-fold cross-validation. Em cada fold, o modelo base é treinado em k-1 partes e prevê na parte deixada de fora. No final, você monta um dataset de treino para o meta-learner com as previsões "out-of-fold" de todos os modelos.

Implementação Passo a Passo em Python

Vamos usar o dataset load_breast_cancer do scikit-learn para um problema de classificação binária. O código abaixo implementa stacking manual com 5-fold.

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import StratifiedKFold, train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, roc_auc_score

Carregar dados

data = load_breast_cancer() X, y = data.data, data.target

Split treino/teste

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Definir modelos base

base_models = [ ('rf', RandomForestClassifier(n_estimators=100, random_state=42)), ('gb', GradientBoostingClassifier(n_estimators=100, random_state=42)), ('svm', SVC(probability=True, random_state=42)) ]

Meta-learner

meta_learner = LogisticRegression(max_iter=1000, random_state=42)

Stacking com 5-fold

n_folds = 5 skf = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=42)

Array para armazenar previsões out-of-fold do treino

meta_features_train = np.zeros((X_train.shape[0], len(base_models)))

Array para previsões do teste (média dos folds)

meta_features_test = np.zeros((X_test.shape[0], len(base_models)))

for i, (name, model) in enumerate(base_models): # Previsões out-of-fold para o treino oof_preds = np.zeros(X_train.shape[0]) test_preds_fold = np.zeros((X_test.shape[0], n_folds))

for fold, (train_idx, val_idx) in enumerate(skf.split(X_train, y_train)):
    X_tr, y_tr = X_train[train_idx], y_train[train_idx]
    X_val = X_train[val_idx]
    
    # Treinar modelo no fold
    model_clone = model.__class__(**model.get_params())
    model_clone.fit(X_tr, y_tr)
    
    # Prever no fold de validação
    oof_preds[val_idx] = model_clone.predict_proba(X_val)[:, 1]
    # Prever no teste
    test_preds_fold[:, fold] = model_clone.predict_proba(X_test)[:, 1]

# Média das previsões do teste nos folds
meta_features_test[:, i] = np.mean(test_preds_fold, axis=1)
meta_features_train[:, i] = oof_preds

Treinar meta-learner

meta_learner.fit(meta_features_train, y_train)

Prever no teste

final_preds = meta_learner.predict(meta_features_test) final_proba = meta_learner.predict_proba(meta_features_test)[:, 1]

print(f"Acurácia Stacking: {accuracy_score(y_test, final_preds):.4f}") print(f"AUC Stacking: {roc_auc_score(y_test, final_proba):.4f}")

Resultados e Análise

Em uma execução típica, a acurácia do stacking fica em torno de 97% a 98%, enquanto modelos individuais como Random Forest e SVM giram em torno de 95% a 96%. A vantagem é consistente, mas o custo computacional é maior — você treina cada modelo base k vezes.

A tabela mostra o ganho real. O stacking não é mágico — ele depende da diversidade dos modelos base. Se todos os modelos forem muito parecidos, o ganho é marginal.

Blending: A Versão Simplificada e Rápida

O que Muda?

Blending é uma versão mais simples do stacking. Em vez de usar k-fold cross-validation, você separa um holdout set (geralmente 10% a 20% do treino) para gerar as previsões que alimentarão o meta-learner. O resto do treino é usado para treinar os modelos base.

A vantagem? Menos código, menos tempo de treino. A desvantagem? Você usa menos dados para treinar os modelos base e o meta-learner, o que pode aumentar a variância.

Implementação em Python

Vamos usar o mesmo dataset e modelos base, mas com uma separação simples de 80/20 dentro do treino.

# Dividir o treino em treino_base e holdout
X_train_base, X_holdout, y_train_base, y_holdout = train_test_split(
    X_train, y_train, test_size=0.2, random_state=42
)

Treinar modelos base no treino_base

for name, model in base_models: model.fit(X_train_base, y_train_base)

Gerar previsões no holdout

meta_features_holdout = np.zeros((X_holdout.shape[0], len(base_models))) for i, (name, model) in enumerate(base_models): meta_features_holdout[:, i] = model.predict_proba(X_holdout)[:, 1]

Treinar meta-learner no holdout

meta_learner_blend = LogisticRegression(max_iter=1000) meta_learner_blend.fit(meta_features_holdout, y_holdout)

Gerar previsões no teste

meta_features_test_blend = np.zeros((X_test.shape[0], len(base_models))) for i, (name, model) in enumerate(base_models): meta_features_test_blend[:, i] = model.predict_proba(X_test)[:, 1]

final_preds_blend = meta_learner_blend.predict(meta_features_test_blend) final_proba_blend = meta_learner_blend.predict_proba(meta_features_test_blend)[:, 1]

print(f"Acurácia Blending: {accuracy_score(y_test, final_preds_blend):.4f}") print(f"AUC Blending: {roc_auc_score(y_test, final_proba_blend):.4f}")

Quando Usar Cada Um?

Blending é ideal para prototipagem rápida. Se você está explorando features ou testando combinações de modelos, ele dá uma resposta em minutos, não horas. Stacking é para a fase final, quando você quer extrair cada gota de performance.

O Meta-Learner Ideal: Leve e Eficaz

Um erro comum é usar um meta-learner complexo, como outra Random Forest. Isso pode levar a overfitting, já que as features (previsões dos modelos base) já são de alta qualidade. A regra de ouro em 2026 continua sendo: meta-learner simples.

A Regressão Logística é a escolha mais popular. Ela é rápida, interpretável (os coeficientes mostram a importância de cada modelo base) e difícil de overfittar. Em testes no dataset Adult, a Regressão Logística como meta-learner superou uma Random Forest como meta-learner em 2% de acurácia (UCI Machine Learning Repository).

Outra opção leve é o Ridge Classifier (versão com regularização L2). Funciona bem quando as features (previsões) são correlacionadas.

Cuidados Essenciais com Data Leakage

Data leakage é o inimigo número 1 do stacking. Se você usar as previsões dos modelos base no mesmo dataset em que eles foram treinados, o meta-learner vai aprender a "colar" nos erros de treino, mas falhará na generalização.

A validação cruzada no stacking resolve isso. No blending, o holdout set garante que o meta-learner veja dados "frescos". Mas atenção: nunca use o dataset de teste para gerar features para o meta-learner. Isso é trapaça.

Conclusão: Qual Técnica Levar para a Batalha?

Em 2026, stacking e blending são técnicas maduras e acessíveis. Se você tem tempo e recurso computacional, stacking com k-fold é a escolha padrão para competições e projetos de alto risco. Se a velocidade é prioridade e você precisa de um baseline rápido, blending resolve bem o problema.

O melhor dos dois mundos? Use blending para explorar, encontre a combinação vencedora de modelos base e depois migre para stacking na versão final. É a receita que os tops do Kaggle usam.

Agora é sua vez. Pegue o código, teste no seu dataset e veja a diferença. O ganho de 5% pode estar a algumas linhas de código de distância.

Artigos Relacionados

Confira também: Machine Learning Explicado: Guia Completo para Iniciantes em 2026 Confira também: O Fim dos Pilotos de ML: Como as 'AI Factories' Estão Industrializando o Machine Learning nas Empresas em 2026 Confira também: World Models 2026: Adeus, Próximo Token? — O ML que Realmente Entende o Mundo Físico