Modelos de Árvore em Machine Learning: Guia Completo

Você sabia que, em dados tabulares, os modelos de árvore ainda vencem redes neurais profundas na maioria dos problemas do mundo real?

Enquanto as manchetes celebram modelos de linguagem com bilhões de parâmetros, são as árvores de decisão e seus descendentes que sustentam sistemas de crédito, detecção de fraude e diagnóstico médico em produção. Um estudo publicado no NeurIPS, Why do tree-based models still outperform deep learning on tabular data?, confirmou o que praticantes de Kaggle observam há anos: para dados organizados em tabelas, os modelos de árvore continuam sendo o ponto de partida mais forte.

Neste artigo, quero convidar você a entender essa família de algoritmos do início: o que é uma Árvore de Decisão, por que uma árvore sozinha tem limites, e como Random Forest e Gradient Boosting transformam árvores simples em modelos de alta performance. Tudo com código em Python e resultados reais, usando o scikit-learn.

O que é uma Árvore de Decisão?

Uma Árvore de Decisão (Decision Tree) é um modelo que aprende uma sequência de perguntas sobre os dados. Cada pergunta divide o conjunto em dois grupos mais homogêneos, e a sequência de divisões termina em uma previsão. O processo lembra um jogo de vinte perguntas: a cada resposta, o espaço de possibilidades diminui, até restar uma única conclusão.

Essa estrutura torna a árvore um dos raros modelos de Machine Learning que um ser humano consegue ler. Um médico pode auditar cada ramo de uma árvore de triagem; um analista de crédito pode justificar por que um empréstimo foi negado. Se você quiser revisitar os fundamentos com mais profundidade, temos um artigo dedicado a entender as árvores de decisão em Machine Learning.

Para ver os três algoritmos em ação, vamos usar o dataset Palmer Penguins, que reúne medidas corporais de 344 pinguins de três espécies da Antártida: Adélie, Chinstrap e Gentoo. A tarefa é classificar a espécie a partir de quatro medidas do animal.

# importar os pacotes necessários
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.metrics import accuracy_score

# carregar o dataset a partir do repositório do blog
url = "https://raw.githubusercontent.com/carlosfab/blog-sigmoidal/main/datasets/penguins.csv"
df = pd.read_csv(url).dropna()

Duas medidas do bico já revelam boa parte da estrutura do problema. No gráfico de dispersão abaixo, cada espécie ocupa uma região relativamente bem definida do espaço, com alguma sobreposição entre Adélie e Chinstrap.

Como a árvore aprende as suas regras?

O treinamento de uma árvore consiste em escolher, a cada nó, a pergunta que melhor separa as classes. O algoritmo avalia todas as divisões possíveis e seleciona a que produz os grupos mais puros, segundo critérios como o índice de Gini ou a entropia, descritos na documentação do scikit-learn.

No código abaixo, separamos 70% dos dados para treino e 30% para teste, e limitamos a profundidade da árvore a três níveis. A restrição é proposital: uma árvore rasa é mais fácil de interpretar e menos propensa a memorizar os dados.

# selecionar as variáveis numéricas e o alvo
atributos = ["bill_length_mm", "bill_depth_mm", "flipper_length_mm", "body_mass_g"]
X = df[atributos]
y = df["species"]

# separar em conjuntos de treino (70%) e teste (30%)
X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)

# treinar a árvore de decisão com profundidade limitada
arvore = DecisionTreeClassifier(max_depth=3, random_state=42)
arvore.fit(X_treino, y_treino)

# avaliar a acurácia no conjunto de teste
acc_arvore = accuracy_score(y_teste, arvore.predict(X_teste))
print(f"Acurácia da Árvore de Decisão (teste): {acc_arvore:.4f}")

# Acurácia da Árvore de Decisão (teste): 0.9400

Com apenas três níveis de perguntas, o modelo acerta 94% das classificações no conjunto de teste. E o melhor: podemos desenhar exatamente o que ele aprendeu.

Cada nó mostra a pergunta feita, quantas amostras chegam até ali e qual classe predomina. A primeira divisão usa o comprimento da nadadeira; as seguintes refinam a separação com as medidas do bico. Essa transparência é o grande patrimônio das árvores de decisão.

Onde uma árvore única falha?

Se uma árvore rasa funciona bem, por que não deixá-la crescer sem limites? Porque uma árvore com profundidade livre continua dividindo os dados até isolar praticamente cada exemplo do treino. O modelo deixa de aprender padrões e passa a memorizar casos.

# treinar uma árvore sem limite de profundidade
arvore_profunda = DecisionTreeClassifier(random_state=42)
arvore_profunda.fit(X_treino, y_treino)

acc_treino = accuracy_score(y_treino, arvore_profunda.predict(X_treino))
acc_teste = accuracy_score(y_teste, arvore_profunda.predict(X_teste))

print(f"Acurácia no treino: {acc_treino:.4f}")
print(f"Acurácia no teste:  {acc_teste:.4f}")

# Acurácia no treino: 1.0000
# Acurácia no teste:  0.9500

O resultado expõe o problema clássico de sobreajuste (overfitting): a árvore acerta 100% do conjunto de treino, mas apenas 95% do teste. O modelo construiu regras específicas demais, que descrevem os dados vistos e generalizam mal para dados novos.

A visualização das fronteiras de decisão torna o fenômeno evidente. Treinando os modelos apenas com as duas medidas do bico, a árvore única produz regiões recortadas, com estrias estreitas criadas para acomodar pontos individuais. O Random Forest, ao lado, desenha fronteiras mais suaves e plausíveis.

O que muda quando combinamos centenas de árvores?

O Random Forest, proposto por Leo Breiman no paper Random Forests (2001), ataca o sobreajuste com uma ideia elegante: em vez de confiar em uma única árvore, o algoritmo treina centenas delas e combina as respostas por votação.

A analogia clássica é a sabedoria das multidões. Cada árvore da floresta é treinada com uma amostra aleatória dos dados (bootstrap) e, a cada divisão, considera apenas um subconjunto aleatório das variáveis. As árvores individuais erram, mas erram de formas diferentes; na média, os erros se cancelam. O conceito é o mesmo que exploramos no artigo sobre métodos de ensemble.

# treinar o random forest com 100 árvores
floresta = RandomForestClassifier(n_estimators=100, random_state=42)
floresta.fit(X_treino, y_treino)

acc_floresta = accuracy_score(y_teste, floresta.predict(X_teste))
print(f"Acurácia do Random Forest (teste): {acc_floresta:.4f}")

# Acurácia do Random Forest (teste): 0.9700

A floresta alcança 97% de acurácia no teste, superando as duas versões da árvore única. Além da performance, o Random Forest oferece um subproduto valioso: a importância das variáveis, que mede quanto cada atributo contribui para as decisões do conjunto.

O gráfico mostra que o comprimento do bico e o comprimento da nadadeira concentram a maior parte do poder preditivo. Em projetos reais, essa análise orienta a coleta de dados e a conversa com especialistas do domínio.

E se cada árvore aprendesse com os erros da anterior?

O Gradient Boosting organiza as árvores de outra maneira. Em vez de treiná-las em paralelo e votar, o algoritmo as constrói em sequência: cada nova árvore é ajustada para corrigir os erros residuais do conjunto anterior. O modelo final é uma soma ponderada de árvores rasas, refinada iteração após iteração.

# treinar o gradient boosting
boosting = GradientBoostingClassifier(n_estimators=100, random_state=42)
boosting.fit(X_treino, y_treino)

acc_boosting = accuracy_score(y_teste, boosting.predict(X_teste))
print(f"Acurácia do Gradient Boosting (teste): {acc_boosting:.4f}")

# Acurácia do Gradient Boosting (teste): 0.9800

Com 98% de acurácia no teste, o Gradient Boosting entrega o melhor resultado desta divisão treino/teste. Essa família de algoritmos deu origem a implementações otimizadas como o XGBoost e o LightGBM, dominantes em competições de dados tabulares. Se você quiser ir além da versão do scikit-learn, temos um tutorial completo de XGBoost em Python.

Qual modelo de árvore escolher?

Uma única divisão treino/teste pode favorecer um modelo por sorte. Para uma comparação mais robusta, avaliamos os três algoritmos com validação cruzada de 5 partições sobre o dataset completo.

# comparar os três modelos com validação cruzada (5 folds)
modelos = {
    "Árvore de Decisão": DecisionTreeClassifier(max_depth=3, random_state=42),
    "Random Forest": RandomForestClassifier(n_estimators=100, random_state=42),
    "Gradient Boosting": GradientBoostingClassifier(n_estimators=100, random_state=42),
}

for nome, modelo in modelos.items():
    scores = cross_val_score(modelo, X, y, cv=5)
    print(f"{nome}: {scores.mean():.4f} (+/- {scores.std():.4f})")

# Árvore de Decisão: 0.9429 (+/- 0.0239)
# Random Forest: 0.9790 (+/- 0.0154)
# Gradient Boosting: 0.9760 (+/- 0.0153)

Os números contam uma história consistente. Os dois métodos de conjunto superam a árvore única por uma margem clara, com acurácias médias de 97,9% para o Random Forest e 97,6% para o Gradient Boosting, contra 94,3% da Árvore de Decisão. Entre os dois ensembles, a diferença fica dentro do desvio padrão: neste dataset, eles empatam na prática.

A escolha, portanto, depende do contexto do seu problema:

• Árvore de Decisão: quando a interpretabilidade é requisito, como em decisões regulatórias e sistemas auditáveis.
• Random Forest: quando você busca robustez com pouco ajuste de hiperparâmetros; é um excelente primeiro modelo de referência.
• Gradient Boosting: quando cada fração de acurácia importa e há tempo para ajustar taxa de aprendizado, profundidade e número de estimadores.

Takeaways

• Árvores de decisão aprendem perguntas, e por isso são interpretáveis: cada previsão pode ser auditada nó a nó, uma propriedade rara em Machine Learning.
• Uma árvore sem limites memoriza o treino: no nosso experimento, a acurácia de 100% no treino caiu para 95% no teste, o retrato clássico do sobreajuste.
• Ensembles convertem árvores fracas em modelos fortes: o Random Forest reduz a variância pela votação de árvores independentes; o Gradient Boosting refina os erros em sequência.
• Em dados tabulares, comece por modelos de árvore: a literatura recente e a prática em competições confirmam que eles seguem sendo a referência a ser batida.
• Valide com mais de uma partição: a validação cruzada revelou um empate técnico entre os ensembles que uma única divisão treino/teste esconderia.

Se este artigo ajudou você a organizar o mapa dos modelos de árvore, o notebook completo está disponível no botão do início da página. Execute, modifique os hiperparâmetros e observe como as fronteiras de decisão reagem: a intuição que você constrói experimentando vale mais do que qualquer leitura passiva.