Florestas Aleatórias

Florestas aleatórias são um dos modelos “padrão” mais confiáveis para aprendizado de máquina (machine learning) tabular. Elas combinam muitas Árvores de Decisão em um conjunto (ensemble) no qual cada árvore é treinada em uma versão ligeiramente diferente do conjunto de dados e usa aleatoriedade durante a seleção de divisões. Isso reduz o sobreajuste (variância) enquanto preserva grande parte da flexibilidade que torna as árvores atraentes.

Em alto nível:

  • Treinamento: construir muitas árvores de decisão usando amostras bootstrap dos dados de treinamento e subamostragem de atributos em cada divisão.
  • Predição: agregar as previsões das árvores por votação majoritária (classificação) ou média (regressão).

Florestas aleatórias foram introduzidas por Leo Breiman (2001) e permanecem uma linha de base forte para muitos problemas do mundo real.

O que é uma Floresta Aleatória?

Uma floresta aleatória (random forest, RF) é um conjunto de árvores de decisão treinadas com bagging (bootstrap aggregating) mais aleatoriedade extra na seleção de atributos.

Ela oferece suporte a duas principais tarefas supervisionadas:

  • RandomForestClassifier: prevê um rótulo de classe (e frequentemente probabilidades de classe)
  • RandomForestRegressor: prevê um valor contínuo

Comparada a uma única árvore, uma floresta aleatória tipicamente:

  • generaliza melhor (menos sobreajuste)
  • é menos sensível a ruído
  • exige pré-processamento mínimo para atributos numéricos
  • fornece diagnósticos úteis embutidos, como avaliação fora da sacola (out-of-bag evaluation) e importância de atributos

Por que florestas aleatórias funcionam: bagging + descorelação

Árvores de decisão são aprendizes de alta variância: pequenas mudanças nos dados podem produzir árvores muito diferentes. Florestas aleatórias reduzem essa variância por dois mecanismos.

1) Bootstrap (bagging)

Cada árvore é treinada em uma amostra bootstrap: um conjunto de dados criado ao amostrar n linhas de treinamento com reposição a partir das n linhas originais.

Consequências:

  • Algumas linhas de treinamento aparecem várias vezes na amostra bootstrap de uma determinada árvore.
  • Cerca de 63,2% dos exemplos de treinamento únicos aparecem em cada amostra bootstrap, em média.
  • Os ~36,8% restantes ficam de fora e se tornam os exemplos fora da sacola (out-of-bag) daquela árvore.

Bagging reduz a variância ao fazer a média de muitos modelos “ruidosos”.

2) Subamostragem de atributos (método do subespaço aleatório)

Se cada árvore sempre escolhe divisões a partir de todos os atributos, muitas árvores podem acabar muito semelhantes — especialmente quando alguns preditores fortes dominam. Florestas aleatórias reduzem a correlação entre árvores ao restringir os atributos candidatos para divisão em cada nó:

  • Em cada divisão, considerar apenas um subconjunto aleatório de atributos (frequentemente chamado mtry ou max_features).
  • Isso força diversidade entre as árvores, melhorando a redução de variância obtida pela média.

Essa “descorelação” é uma das principais razões pelas quais florestas aleatórias frequentemente superam o bagging puro de árvores.

O algoritmo (conceitual)

Dado o conjunto de treinamento ((X, y)), número de árvores (T):

Para (t = 1 \dots T):

  1. Sortear uma amostra bootstrap ((X^{(t)}, y^{(t)})) de ((X, y)).
  2. Treinar uma árvore de decisão em ((X^{(t)}, y^{(t)})), mas em cada divisão:
    • amostrar aleatoriamente um subconjunto de atributos de tamanho (m)
    • escolher a melhor divisão apenas entre esses (m) atributos (usando redução de impureza / redução de perda)

Para prever um novo ponto (x):

  • Classificação: agregar os votos das árvores (ou fazer a média das probabilidades previstas)
  • Regressão: fazer a média dos valores previstos

Agregação de predição

Classificação: votar ou fazer média de probabilidades

Dois métodos comuns de agregação:

  • Votação dura (hard voting): cada árvore prevê uma classe; a floresta prevê a maioria.
  • Votação suave (soft voting) (mais comum em bibliotecas): cada árvore produz probabilidades de classe; a floresta faz a média e seleciona a maior.

A votação suave usa mais informação e permite ajuste de limiar (útil em problemas desbalanceados).

Regressão: média (ou às vezes mediana)

Florestas aleatórias para regressão tipicamente usam a média das previsões das árvores:

[ \hat{y}(x) = \frac{1}{T}\sum_{t=1}^T \hat{y}^{(t)}(x) ]

Essa média estabiliza previsões ruidosas nas folhas.

Principais hiperparâmetros (e o que eles controlam)

Florestas aleatórias têm muitos ajustes, mas alguns dominam desempenho e computação. Os nomes variam entre bibliotecas; abaixo estão termos comuns do scikit-learn.

Tamanho do conjunto

  • n_estimators: número de árvores.
    • Mais árvores geralmente melhoram o desempenho até retornos decrescentes.
    • Também aumenta o tempo de treinamento e de predição (mas é fácil paralelizar).
    • Dica prática: comece com 300–1000 para resultados estáveis; ajuste conforme o orçamento de tempo.

Força da árvore vs. diversidade da floresta

Esses parâmetros controlam o sobreajuste e o quão correlacionadas as árvores ficam.

  • max_features: número (ou fração) de atributos considerados em cada divisão.
    • Valores menores → mais diversidade, menos correlação, às vezes melhor generalização.
    • Padrões frequentemente são:
      • classificação: sqrt(p)
      • regressão: p ou p/3 dependendo da implementação
  • max_depth: profundidade máxima de cada árvore.
    • Árvores mais rasas → maior viés, menor variância, mais rápidas.
    • Árvores profundas podem sobreajustar individualmente, mas a floresta frequentemente permanece robusta.
  • min_samples_split, min_samples_leaf: mínimo de amostras exigidas para dividir ou permanecer em uma folha.
    • Aumentar min_samples_leaf é um regularizador forte e pode melhorar bastante a generalização, especialmente com alvos ruidosos.
  • bootstrap (True/False): se deve usar amostras bootstrap.
    • Florestas aleatórias padrão usam bootstrap=True.
    • Desabilitar o bootstrap pode se comportar mais como “pasting” e altera o significado da pontuação fora da sacola.

Amostragem de dados e tratamento de desbalanceamento

  • class_weight (classificação): pode dar maior peso a classes minoritárias.
  • max_samples (se suportado): controla o tamanho da amostra bootstrap por árvore (por exemplo, 80% das linhas).

Aleatoriedade e reprodutibilidade

  • random_state: semente para tornar resultados repetíveis.
  • n_jobs: paralelismo; florestas aleatórias são extremamente paralelizáveis entre árvores.

Avaliação fora da sacola (OOB)

Como cada árvore é treinada em uma amostra bootstrap, cada exemplo de treinamento fica fora da sacola para aproximadamente 36,8% das árvores. Podemos estimar o desempenho de generalização sem um conjunto de validação separado:

  1. Para cada linha de treinamento (i), coletar previsões das árvores nas quais (i) foi OOB.
  2. Agregar essas previsões em uma predição OOB para (i).
  3. Calcular uma pontuação OOB (acurácia, (R^2), etc.) usando predições OOB vs. alvos verdadeiros.

Benefícios:

  • Validação interna rápida sem Validação Cruzada
  • Ajuda a ajustar hiperparâmetros com eficiência

Ressalvas:

  • OOB geralmente é uma boa aproximação, mas ainda é uma estimativa.
  • Se você fizer pré-processamento pesado (por exemplo, codificação por alvo), deve evitar vazamento; OOB não é automaticamente “à prova de vazamento”.

Importância de atributos

Florestas aleatórias oferecem múltiplas formas de estimar quais atributos importam. Essas são heurísticas, não causalidade.

1) Importância baseada em impureza (MDI / importância de Gini)

Cada vez que um atributo é usado para dividir um nó, ele contribui para a redução na impureza (por exemplo, Gini, entropia, MSE). Somar essas reduções ao longo de todas as árvores fornece uma pontuação de importância.

Pontos fortes:

  • Muito rápida (calculada durante o treinamento)
  • Frequentemente dá uma boa primeira visão

Limitações:

  • Pode ser enviesada em favor de atributos com muitos pontos possíveis de divisão (contínuos ou de alta cardinalidade)
  • Pode distribuir a importância de forma estranha entre atributos correlacionados (a importância “se divide” entre eles)

2) Importância por permutação (recomendada)

Medir quanto o desempenho cai quando os valores de um atributo são permutados aleatoriamente:

  1. Avaliar o modelo em um conjunto de validação (ou predições OOB).
  2. Embaralhar uma coluna de atributo, mantendo as outras fixas.
  3. Reavaliar; a queda de desempenho é a importância.

Pontos fortes:

  • Mais fiel à contribuição preditiva
  • Funciona com qualquer métrica

Limitações:

  • Mais custosa (exige avaliações repetidas)
  • Atributos correlacionados podem mascarar uns aos outros (embaralhar um pode não prejudicar muito se outro correlacionado permanecer)

Para interpretabilidade mais profunda, a importância por permutação pode ser combinada com ferramentas de IA Explicável (por exemplo, dependência parcial, SHAP), com a cautela habitual em relação à correlação.

Pontos fortes e limitações

Pontos fortes

  • Forte desempenho pronto para uso em dados tabulares
  • Lida com não linearidades e interações automaticamente
  • Pouca necessidade de escalonamento de atributos (ao contrário de muitos modelos lineares)
  • Robusta a outliers (em relação a muitos modelos paramétricos)
  • Funciona para classificação e regressão
  • Avaliação OOB embutida (quando o bootstrap está habilitado)
  • Paralelizável e estável para treinar

Limitações

  • Menos interpretável do que uma única árvore (embora mais interpretável do que muitos modelos caixa-preta)
  • Modelos grandes: muitas árvores podem consumir memória significativa
  • Inferência mais lenta do que modelos lineares (a predição exige percorrer muitas árvores)
  • Não é ideal para dados esparsos de dimensionalidade muito alta (por exemplo, texto bag-of-words); modelos lineares ou métodos especializados frequentemente funcionam melhor
  • Extrapolação: como a maioria dos métodos baseados em árvores, a regressão com RF não extrapola bem além do intervalo dos alvos observados
  • Calibração de probabilidades: probabilidades de classificação podem ser mal calibradas; considere Calibração de Modelos
  • Atributos correlacionados podem tornar medidas de importância e interpretação difíceis

Dicas práticas para dados tabulares

Comece com padrões sensatos e depois ajuste alguns parâmetros

Uma sequência prática de ajuste:

  1. Defina n_estimators alto o suficiente (por exemplo, 500) para estabilizar o desempenho OOB/validação.
  2. Ajuste regularização:
    • min_samples_leaf (frequentemente muito impactante)
    • max_depth (opcional; None frequentemente é adequado com min_samples_leaf suficiente)
  3. Ajuste diversidade:
    • max_features (menor pode generalizar melhor)
  4. Considere class_weight para classificação desbalanceada.

Florestas aleatórias frequentemente são tolerantes; você consegue a maior parte dos ganhos ajustando apenas 2–4 parâmetros.

Use a pontuação OOB como verificação rápida, não como palavra final

OOB é excelente para iteração, mas para relatório final use um protocolo adequado de avaliação:

Trate valores ausentes explicitamente (em muitas bibliotecas)

Implementações clássicas de RF geralmente exigem ausência de valores faltantes:

  • Impute (mediana/moda) ou use imputação baseada em modelo
  • Algumas bibliotecas suportam divisões com valores ausentes; verifique sua cadeia de ferramentas

Codifique variáveis categóricas com cuidado

Muitas bibliotecas populares de RF (incluindo scikit-learn) exigem entradas numéricas:

  • Codificação one-hot é comum e robusta
  • Para categorias de alta cardinalidade, considere codificação por alvo cuidadosamente (evite vazamento) ou modelos alternativos projetados para categóricas

Atenção ao vazamento de dados no pré-processamento

Se você imputar, escalar ou codificar usando informação do conjunto completo antes de dividir, você pode vazar informação do alvo. Use pipelines e ajuste o pré-processamento apenas nos folds de treino.

Para classificação desbalanceada: ajuste limiares e métricas

Florestas aleatórias podem produzir probabilidades, mas você pode precisar de:

  • class_weight="balanced" (ou pesos personalizados)
  • ajuste de limiar com base em trade-offs de precisão/recall
  • métricas como PR-AUC, F1, acurácia balanceada (veja Aprendizado com Desbalanceamento)

Calibre probabilidades quando decisões dependem de risco

Se probabilidades orientam decisões de negócio (risco de crédito, triagem médica), calibre:

  • escalonamento de Platt (calibração logística) ou regressão isotônica via Calibração de Modelos
  • Use um conjunto de validação adequado para calibração

Exemplos práticos (Python / scikit-learn)

Exemplo 1: Classificação com pontuação OOB

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score

X, y = make_classification(
    n_samples=5000, n_features=30, n_informative=10, n_redundant=5,
    weights=[0.8, 0.2], random_state=42
)

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

rf = RandomForestClassifier(
    n_estimators=600,
    max_features="sqrt",
    min_samples_leaf=5,
    oob_score=True,
    bootstrap=True,
    n_jobs=-1,
    random_state=42
)

rf.fit(X_train, y_train)

print("OOB score (approx. generalization accuracy):", rf.oob_score_)

proba = rf.predict_proba(X_test)[:, 1]
print("Test ROC-AUC:", roc_auc_score(y_test, proba))

Notas:

  • min_samples_leaf=5 frequentemente melhora a estabilidade e a qualidade das probabilidades.
  • oob_score=True fornece uma estimativa interna rápida, útil durante a iteração.

Exemplo 2: Regressão e importância por permutação

import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.inspection import permutation_importance
from sklearn.metrics import mean_squared_error

X, y = make_regression(
    n_samples=4000, n_features=25, n_informative=8, noise=15.0, random_state=0
)

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

rf = RandomForestRegressor(
    n_estimators=800,
    max_features=0.5,        # try fractions too
    min_samples_leaf=3,
    n_jobs=-1,
    random_state=0
)

rf.fit(X_train, y_train)
pred = rf.predict(X_test)
rmse = mean_squared_error(y_test, pred, squared=False)
print("Test RMSE:", rmse)

perm = permutation_importance(
    rf, X_test, y_test, n_repeats=10, random_state=0, n_jobs=-1
)

top_idx = np.argsort(perm.importances_mean)[::-1][:10]
print("Top 10 features by permutation importance:", top_idx)

A importância por permutação aqui reflete o quanto cada atributo afeta o desempenho no conjunto de teste, o que frequentemente é mais confiável do que a importância baseada em impureza.

Florestas aleatórias vs. conjuntos de árvores relacionados

Dentro de “árvores de decisão e conjuntos”, florestas aleatórias são um ramo importante. Dois parentes próximos muitas vezes valem a pena considerar:

  • Árvores Extra (Árvores Extremamente Aleatórias): aumentam ainda mais a aleatoriedade ao escolher limiares de divisão de forma mais aleatória. Frequentemente são mais rápidas e às vezes melhores, especialmente quando você quer mais descorelação.
  • Boosting de Gradiente: constrói árvores sequencialmente para corrigir erros. Geralmente atinge maior acurácia com ajuste cuidadoso, mas é mais sensível a hiperparâmetros e pode sobreajustar se não for regularizado.

Regra prática:

  • Quer uma linha de base forte rapidamente e comportamento robusto? Escolha floresta aleatória.
  • Quer potencialmente a melhor acurácia tabular da categoria e pode ajustar mais? Experimente boosting de gradiente.
  • Quer algo como RF, mas às vezes mais rápido/mais aleatorizado? Experimente árvores extra.

Resumo

Florestas aleatórias combinam:

  • bootstrap (bagging) para reduzir variância,
  • subamostragem de atributos para descorelacionar árvores,
  • agregação (voto/média) para previsões estáveis,

tornando-as um modelo poderoso e prático para classificação e regressão tabulares. Práticas-chave incluem ajustar min_samples_leaf, usar pontuação OOB para iteração rápida, confiar em importância por permutação para atribuição de atributos mais confiável e tratar dados categóricos/ausentes com cuidado para evitar vazamento.

Para muitos fluxos de trabalho aplicados de aprendizado de máquina, uma floresta aleatória bem ajustada continua sendo um dos melhores “primeiros modelos sérios” para tentar em dados estruturados.