Extra Trees (Árvores Extremamente Aleatorizadas)

Visão geral

Árvores Extras (Extra Trees) (também chamadas de Árvores Extremamente Aleatorizadas (Extremely Randomized Trees)) são um método de comitê (ensemble) para aprendizado supervisionado (supervised learning) que constrói muitas árvores de decisão (decision trees) e faz a média de suas predições (regressão (regression)) ou votos (classificação (classification)). Elas são estreitamente relacionadas a Florestas Aleatórias e à Agregação por Bootstrap, mas inserem mais aleatoriedade na construção das árvores — mais notavelmente ao escolher limiares de divisão (split thresholds) aleatoriamente em vez de buscar o melhor limiar entre todos os pontos de corte possíveis.

Essa aleatoriedade extra tende a:

  • Reduzir a variância (variance) (menos sobreajuste (overfitting) do que uma única árvore profunda)
  • Treinar mais rápido do que métodos que buscam exaustivamente os limiares de divisão
  • Ter desempenho muito forte como linha de base (baseline) em dados tabulares (tabular data)/dados estruturados (structured data), especialmente quando as relações são não lineares (nonlinear) e incluem interações entre atributos (feature interactions)

As Árvores Extras foram introduzidas por Geurts, Ernst e Wehenkel (2006) e estão amplamente disponíveis em bibliotecas como scikit-learn (ExtraTreesClassifier, ExtraTreesRegressor).

Como as Árvores Extras funcionam

As Árvores Extras são um comitê de árvores de decisão, então ajuda relembrar como um modelo padrão de Árvores de Decisão aprende:

  1. Começa na raiz com o conjunto de treinamento (training set) completo (ou um subconjunto).
  2. Em cada nó, escolhe um atributo e um limiar para dividir os dados em dois filhos.
  3. Escolhe divisões que melhoram a “pureza” (classificação) ou reduzem variância/erro (regressão).
  4. Recursiona até que uma condição de parada seja atendida (limite de profundidade, mínimo de amostras etc.).

As Árvores Extras mantêm essa estrutura geral, mas modificam como as divisões são escolhidas.

Divisão aleatorizada (a ideia-chave)

Em cada nó, as Árvores Extras normalmente fazem:

  1. Selecionam aleatoriamente um subconjunto de atributos (semelhante às Florestas Aleatórias).
  2. Para cada atributo selecionado, amostram um limiar de divisão aleatoriamente (por exemplo, uniformemente entre o valor mínimo e máximo daquele atributo entre as amostras no nó).
  3. Avaliam esses candidatos aleatórios de divisão e escolhem o melhor entre eles (melhor redução de impureza / redução de variância).

Assim, em vez de buscar muitos limiares por atributo (muitas vezes caro), as Árvores Extras avaliam um pequeno conjunto de limiares aleatórios.

Isso difere das Florestas Aleatórias, que geralmente:

  • selecionam atributos aleatoriamente, mas então
  • otimizam o limiar de divisão (escolhem o melhor limiar encontrado nos dados) para esses atributos.

Uso do conjunto completo vs. bootstrap

Uma distinção “padrão” comum:

  • Florestas Aleatórias: cada árvore é treinada em uma amostra bootstrap (bootstrap sample) (amostragem com reposição).
  • Árvores Extras: cada árvore frequentemente é treinada com o conjunto completo de dados (sem bootstrap), e a aleatoriedade vem principalmente dos limiares aleatórios (e de subconjuntos aleatórios de atributos).

Na prática (e em muitas implementações), você também pode habilitar bootstrap em Árvores Extras, mas as Árvores Extras clássicas frequentemente usam o conjunto completo.

Agregação

Quando muitas árvores são treinadas:

  • Regressão: as predições são tiradas pela média entre as árvores.
  • Classificação: as probabilidades de classe são tiradas pela média, e a classe prevista normalmente é o argmax (argmax).

Essa agregação é a mesma ideia de alto nível do bagging: muitos aprendizes de alta variância + média ⇒ menor variância.

Relação com bagging e Florestas Aleatórias

As Árvores Extras ficam na mesma família de ensembles de árvores baseados em bagging:

Agregação por Bootstrap (Bagging / Bootstrap Aggregating)

  • Treina muitos aprendizes-base (frequentemente árvores de decisão completas) em diferentes amostras bootstrap.
  • Faz média/votação das predições.
  • A aleatoriedade vem da amostragem dos dados.

Veja: Agregação por Bootstrap

Florestas Aleatórias

  • Bagging + seleção aleatória de atributos em cada divisão.
  • Tipicamente escolhe o melhor limiar para os atributos escolhidos.
  • A aleatoriedade vem tanto do bootstrap quanto da subamostragem de atributos.

Veja: Florestas Aleatórias

Árvores Extras

  • Frequentemente usa o conjunto completo por árvore (sem bootstrap por padrão).
  • Seleção aleatória de atributos em cada divisão (como Florestas Aleatórias).
  • Limiar aleatório para divisões (aleatoriedade mais forte do que em Florestas Aleatórias).

Uma forma útil de lembrar:

  • Bagging: aleatoriza os dados
  • Florestas Aleatórias: aleatoriza dados + atributos
  • Árvores Extras: aleatoriza atributos + limiares (e opcionalmente dados)

Por que a aleatoriedade extra ajuda (intuição viés–variância)

Ensembles de árvores tratam, em grande parte, de gerenciar o Compromisso Viés–Variância:

  • Uma única árvore de decisão profunda tem baixo viés (bias), mas alta variância (pode ajustar ruído).
  • Fazer a média de muitas árvores reduz a variância se as árvores não forem muito correlacionadas.

As Árvores Extras promovem a descorrelação (decorrelation) entre árvores de forma mais agressiva do que as Florestas Aleatórias:

  • Se duas árvores veem dados semelhantes e fazem escolhas de divisão semelhantes, a média não ajuda muito.
  • Ao forçar limiares de divisão aleatórios, as Árvores Extras tornam as árvores mais diversas mesmo quando treinadas no mesmo conjunto de dados.

Isso tipicamente leva a:

  • Menor variância do que uma configuração comparável de Floresta Aleatória
  • Às vezes um viés ligeiramente maior (porque as divisões não são otimizadas tão cuidadosamente)
  • Frequentemente excelente generalização, especialmente quando você pode usar muitas árvores

Principais hiperparâmetros e como afetam o desempenho

Os hiperparâmetros (hyperparameters) variam um pouco por biblioteca, mas as ideias centrais são consistentes.

Número de árvores (`n_estimators`)

  • Mais árvores geralmente melhora o desempenho (retornos decrescentes).
  • Mais árvores reduz variância e estabiliza estimativas de importância de atributos.
  • O treinamento é paralelizável.

Orientação prática:

  • Comece com 300–1000 árvores para desempenho forte, se o tempo de treinamento permitir.
  • Para linhas de base rápidas, 100–300 costuma ser suficiente.

Subamostragem de atributos (`max_features`)

Controla quantos atributos são considerados em cada divisão.

Configurações comuns:

  • Padrões de classificação frequentemente usam sqrt(p) onde p é o número de atributos.
  • Padrões de regressão às vezes usam p (todos os atributos) ou uma fração.

Efeitos:

  • max_features menor ⇒ mais aleatoriedade ⇒ menor correlação ⇒ menor variância (mas pode aumentar viés).
  • max_features maior ⇒ divisões mais fortes ⇒ potencialmente menor viés (mas maior correlação).

Orientação prática:

  • Se houver sobreajuste ou resultados instáveis: tente diminuir max_features.
  • Se houver subajuste (underfitting): tente aumentar max_features.

Aleatoriedade na divisão (limiares aleatórios)

Em Árvores Extras, a aleatoriedade é intrínseca: os limiares não são otimizados sobre todos os pontos de corte possíveis.

No scikit-learn especificamente, você normalmente controla essa aleatoriedade indiretamente via:

  • random_state (reprodutibilidade)
  • max_features (quantos limiares aleatórios são avaliados, já que cada atributo escolhido recebe um limiar aleatório)

Algumas descrições teóricas mencionam amostrar múltiplos limiares aleatórios por atributo em um nó; muitas implementações comuns amostram um por atributo e escolhem o melhor entre os candidatos amostrados.

Tamanho da árvore / parâmetros de regularização

Mesmo que ensembles reduzam sobreajuste, árvores individuais ainda podem ser controladas:

  • max_depth: limita a profundidade da árvore.
    • Árvores mais profundas capturam mais interações, mas podem ajustar ruído.
  • min_samples_split: mínimo de amostras necessário para dividir um nó.
  • min_samples_leaf: mínimo de amostras necessário em uma folha (muitas vezes muito importante para controle de ruído).
  • max_leaf_nodes: limita o número de folhas.
  • ccp_alpha: poda por custo-complexidade em algumas bibliotecas.

Orientação prática:

  • Se seu modelo de Árvores Extras sobreajusta (pontuação de treino muito melhor do que validação):
    • Aumente min_samples_leaf (frequentemente a primeira coisa a tentar)
    • Limite max_depth
  • Se subajusta:
    • Permita árvores mais profundas e folhas menores

Bootstrap e subamostragem (`bootstrap`, `max_samples`)

Algumas implementações permitem:

  • bootstrap=True: treinar cada árvore em uma amostra bootstrap
  • max_samples: amostrar uma fração do conjunto de dados por árvore

Efeitos:

  • O bootstrap pode descorrelacionar ainda mais as árvores (às vezes ajuda).
  • Usar o conjunto completo por árvore é comum em Árvores Extras e frequentemente funciona bem.

Critério de qualidade da divisão (`criterion`)

  • Classificação: impureza de Gini (Gini impurity), entropia/variantes de log loss
  • Regressão: erro quadrático (MSE), erro absoluto (MAE) em algumas implementações

Isso geralmente importa menos do que n_estimators, max_features e controles de tamanho de folha.

Exemplo prático (scikit-learn): classificação em dados tabulares

Abaixo está um fluxo de trabalho típico incluindo pré-processamento. As Árvores Extras lidam bem com escalas mistas de atributos, mas não lidam inerentemente com valores ausentes em muitas implementações comuns, então imputação (imputation) é típica.

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.metrics import roc_auc_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.2, random_state=42, stratify=y
)

model = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("clf", ExtraTreesClassifier(
        n_estimators=500,
        max_features="sqrt",
        min_samples_leaf=2,
        random_state=42,
        n_jobs=-1
    ))
])

model.fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]
print("ROC AUC:", roc_auc_score(y_test, proba))

Notas:

  • min_samples_leaf=2 é um regularizador pequeno, mas frequentemente útil.
  • Se você precisa de probabilidades bem calibradas, considere Calibração de Modelos (ensembles de árvores podem ser excessivamente confiantes).

Exemplo prático: regressão em dados tabulares

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.ensemble import ExtraTreesRegressor
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.2, random_state=42
)

reg = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("etr", ExtraTreesRegressor(
        n_estimators=800,
        max_features=0.7,
        min_samples_leaf=3,
        random_state=42,
        n_jobs=-1
    ))
])

reg.fit(X_train, y_train)
pred = reg.predict(X_test)
rmse = np.sqrt(mean_squared_error(y_test, pred))
print("RMSE:", rmse)

Um “pega” comum para regressão: as Árvores Extras (como a maioria dos ensembles de árvores padrão) não extrapolam muito bem além do intervalo de alvos visto no treino, porque folhas predizem médias de alvos observados.

Quando Árvores Extras tendem a funcionar bem

As Árvores Extras são frequentemente uma escolha de primeira linha para dados tabulares quando você quer forte acurácia com mínima engenharia de atributos (feature engineering).

Elas tendem a funcionar bem quando:

  • O conjunto de dados tem padrões não lineares e interações entre atributos
  • Você tem uma mistura de atributos informativos e fracos/ruidosos (a aleatorização ajuda na robustez)
  • Você quer uma linha de base forte sem pré-processamento pesado
  • Você quer bom desempenho com relativamente pouco ajuste de hiperparâmetros
  • A velocidade de treinamento importa (especialmente em comparação com árvores que otimizam limiares)

Domínios de aplicação comuns:

  • Risco de crédito / detecção de fraude (com avaliação apropriada e controle de vazamento de dados)
  • Predição de churn de clientes
  • Modelagem de resposta de marketing
  • Manutenção preditiva de sensores / IoT
  • Classificação biomédica tabular (exames, medições)
  • Qualquer problema de aprendizado supervisionado “tipo planilha”

Para muitas tarefas tabulares, Árvores Extras e Florestas Aleatórias são excelentes linhas de base antes de passar para métodos de boosting como Boosting por Gradiente (ou bibliotecas especializadas como XGBoost/LightGBM/CatBoost).

Pontos fortes e limitações

Pontos fortes

  • Linha de base de alta qualidade para ML tabular
  • Treinamento rápido em relação à busca exaustiva de divisões (dependente da implementação)
  • Lida com:
    • não linearidades
    • interações
    • transformações monotônicas (sem necessidade de escalar atributos)
  • Suporta inerentemente:
    • classificação multiclasse (multiclass classification)
    • problemas de saída múltipla (multioutput) (em algumas bibliotecas)

Limitações / pegadinhas

  • Não é ideal para atributos de texto esparsos e de muito alta dimensionalidade em comparação com modelos lineares (embora ainda possa funcionar em alguns casos).
  • Alto uso de memória com muitas árvores profundas.
  • Valores ausentes: muitas implementações padrão exigem imputação (veja Imputação).
  • Atributos categóricos frequentemente precisam de codificação (por exemplo, Codificação One-Hot), a menos que você use uma biblioteca com suporte nativo a categorias.
  • Calibração de probabilidades pode ser imperfeita; considere calibração para sistemas de tomada de decisão.
  • Menos interpretável do que uma única árvore; use ferramentas pós-hoc.

Dicas práticas de ajuste

Uma estratégia simples e eficaz de ajuste:

  1. Defina n_estimators alto o suficiente para estabilidade (por exemplo, 300–1000).
  2. Ajuste a capacidade do modelo e o “suavizamento”:
    • min_samples_leaf (tente 1, 2, 5, 10, 20)
    • max_depth (None, 10, 20, 30)
  3. Ajuste aleatoriedade/força:
    • max_features (sqrt, log2, 0.3, 0.5, 0.8)
  4. Opcionalmente, tente bootstrap=True e/ou max_samples < 1.0.

Use Validação Cruzada e/ou um conjunto de validação. Para classificação desbalanceada, prefira métricas como AUC ROC (ROC AUC), AUC PR (PR AUC), ou métricas sensíveis a custo (cost-sensitive) em vez de acurácia.

Veja também: Ajuste de Hiperparâmetros

Interpretabilidade: importância de atributos e além

As Árvores Extras suportam ferramentas comuns de interpretabilidade, mas é importante usá-las corretamente.

Importância de atributos baseada em impureza

Muitas bibliotecas oferecem “importância de Gini (Gini importance)” / “MDI” (mean decrease in impurity). É rápida, mas pode ser enviesada em favor de:

  • atributos contínuos
  • atributos de alta cardinalidade
  • atributos com muitas divisões possíveis

Veja: Importância de Atributos

Importância por permutação (recomendação como linha de base)

A importância por permutação (permutation importance) mede a mudança no desempenho quando um atributo é embaralhado aleatoriamente.

Veja: Importância por Permutação

Valores SHAP (explicações locais)

Para explicações por linha, métodos no estilo valores SHAP (SHAP values) podem ser usados com ensembles de árvores.

Veja: SHAP

Como Árvores Extras se comparam na prática

Árvores Extras vs Florestas Aleatórias

Árvores Extras frequentemente:

  • treinam mais rápido (menos otimização de limiar)
  • generalizam de forma semelhante ou às vezes melhor (menor variância)
  • podem ser um pouco mais enviesadas em alguns problemas

Se Florestas Aleatórias estiverem sobreajustando ou instáveis, Árvores Extras podem melhorar a generalização “de graça”. Se você precisa de máxima acurácia e pode arcar com ajuste fino, vale a pena testar ambas.

Árvores Extras vs Boosting por Gradiente

Árvores com boosting podem superar ensembles no estilo bagging em muitos conjuntos de dados estruturados, mas:

  • boosting é mais sensível a hiperparâmetros
  • boosting pode sobreajustar rótulos ruidosos se não for regularizado
  • Árvores Extras são mais simples, paralelizáveis e fortes como linha de base

Veja: Boosting por Gradiente

Resumo

Árvores Extras (Extra Trees) são um ensemble no estilo bagging de árvores de decisão que aumentam a aleatoriedade ao usar limiares de divisão aleatórios (e tipicamente subconjuntos aleatórios de atributos, frequentemente sem bootstrap). Esse desenho pode reduzir a variância, melhorar a estabilidade e frequentemente acelerar o treinamento, tornando Árvores Extras um modelo poderoso e prático para aprendizado supervisionado tabular.

Se você precisa de uma linha de base confiável para dados estruturados com pouco pré-processamento, Árvores Extras são um dos primeiros modelos que vale a pena tentar — junto com Florestas Aleatórias e (quando você quiser elevar o desempenho) Boosting por Gradiente.