Árvores de decisão: teoria e implementação
Impureza de Gini, ganho de informação, profundidade da árvore e sobreajuste — DecisionTreeClassifier do sklearn.
Árvores de decisão: teoria e implementação é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
O que é uma árvore de decisão
Uma árvore de decisão divide os dados em ramos com base nos valores das características, fazendo perguntas de sim ou não até chegar a uma previsão em um nó folha.
Cada nó interno testa uma característica, cada ramo representa um resultado e cada folha atribui uma classe. As árvores são fáceis de interpretar porque você pode acompanhar o caminho das decisões.
Impureza de Gini
Impureza de Gini mede o quanto as classes estão misturadas em um nó. Um nó puro (com apenas uma classe) tem Gini igual a 0.
A fórmula é Gini = 1 - sum(p_i^2), em que p_i é a fração da classe i. A árvore escolhe as divisões que mais reduzem a impureza.
import numpy as np
def gini(labels):
classes, counts = np.unique(labels, return_counts=True)
probs = counts / counts.sum()
return 1 - np.sum(probs ** 2)
print(gini([0, 0, 1, 1])) # 0.5 (max mix)
print(gini([0, 0, 0, 0])) # 0.0 (pure)Ganho de informação e entropia
Um critério alternativo de divisão é o ganho de informação, baseado na entropia. Entropia é -sum(p_i * log2(p_i)).
Ganho de informação = entropia do elemento pai - entropia ponderada dos elementos filhos. Gini e entropia geralmente produzem árvores semelhantes; Gini é um pouco mais rápido de calcular.
import numpy as np
def entropy(labels):
_, counts = np.unique(labels, return_counts=True)
p = counts / counts.sum()
return -np.sum(p * np.log2(p))
print(entropy([0, 0, 1, 1])) # 1.0
print(entropy([0, 0, 0, 1])) # ~0.81Treinando um DecisionTreeClassifier
O Scikit-learn fornece DecisionTreeClassifier. Você escolhe o critério de divisão com o parâmetro criterion (gini ou entropy).
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, random_state=0)
clf = DecisionTreeClassifier(criterion="gini", random_state=0)
clf.fit(Xtr, ytr)
print("Accuracy:", clf.score(Xte, yte))Ajuste excessivo e max_depth
Uma árvore sem restrições cresce até que todas as folhas sejam puras, memorizando o ruído. Isso causa ajuste excessivo.
O parâmetro max_depth limita a profundidade que a árvore pode alcançar, obrigando-a a generalizar. Menor profundidade = modelo mais simples = menos ajuste excessivo.
from sklearn.tree import DecisionTreeClassifier
shallow = DecisionTreeClassifier(max_depth=3, random_state=0)
deep = DecisionTreeClassifier(max_depth=None, random_state=0)
# shallow generalizes better on unseen data;
# deep often overfits the training setOutros parâmetros de pré-poda
Além de max_depth, você pode controlar o crescimento com:
min_samples_splitquantidade mínima de amostras para dividir um nómin_samples_leafquantidade mínima de amostras em uma folhamax_leaf_nodeslimite para o total de folhas
Todos eles reduzem a variância e combatem o ajuste excessivo.
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier(
max_depth=5,
min_samples_split=10,
min_samples_leaf=5,
random_state=0,
)Visualizando com plot_tree
plot_tree desenha a árvore completa para que você possa ler cada divisão, o valor de Gini e a distribuição das classes em cada nó.
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
clf = DecisionTreeClassifier(max_depth=3).fit(X, y)
plt.figure(figsize=(12, 6))
plot_tree(clf, filled=True, feature_names=load_iris().feature_names)
plt.show()Importâncias das características
Depois do ajuste, feature_importances_ informa quanto cada característica reduziu a impureza em todas as divisões. Os valores somam 1.0.
Essa é uma maneira rápida de classificar quais entradas são mais importantes para o modelo.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
data = load_iris()
clf = DecisionTreeClassifier(max_depth=3).fit(data.data, data.target)
for name, imp in zip(data.feature_names, clf.feature_importances_):
print(f"{name}: {imp:.3f}")Poda por complexidade de custo (ccp_alpha)
A pós-poda faz a árvore completa crescer e depois remove os ramos fracos. O parâmetro ccp_alpha controla o grau de poda: um alfa maior remove mais nós.
Use cost_complexity_pruning_path para encontrar valores de alfa candidatos.
from sklearn.tree import DecisionTreeClassifier
base = DecisionTreeClassifier(random_state=0)
path = base.cost_complexity_pruning_path(Xtr, ytr)
alphas = path.ccp_alphas
pruned = DecisionTreeClassifier(ccp_alpha=0.01, random_state=0)
pruned.fit(Xtr, ytr)Escolhendo o melhor alfa
Para escolher ccp_alpha, treine uma árvore para cada alfa candidato e compare a precisão na validação. O melhor alfa equilibra precisão e simplicidade.
from sklearn.tree import DecisionTreeClassifier
scores = []
for a in alphas:
t = DecisionTreeClassifier(ccp_alpha=a, random_state=0)
t.fit(Xtr, ytr)
scores.append((a, t.score(Xte, yte)))
best = max(scores, key=lambda s: s[1])
print("Best alpha:", best[0])Pontos fortes e limitações
Vantagens: fácil de interpretar, não exige normalização, lida com fronteiras não lineares e com tipos de dados mistos.
Desvantagens: alta variância (pequenas mudanças nos dados podem alterar a árvore), tendência ao ajuste excessivo e apenas divisões alinhadas aos eixos. Essas limitações motivam métodos de conjunto, como as florestas aleatórias.
Verificação rápida
Teste sua compreensão dos conceitos de árvores de decisão.
Recapitulação
Recapitulação: as árvores de decisão dividem os dados usando a impureza de Gini ou o ganho de informação. Controle o ajuste excessivo com pré-poda (max_depth, min_samples_leaf) ou pós-poda (ccp_alpha). Inspecione os modelos com plot_tree e feature_importances_. A alta variância delas motiva os métodos de conjunto.
Perguntas Frequentes
A aula “Árvores de decisão: teoria e implementação” é grátis?
Sim — o texto completo de “Árvores de decisão: teoria e implementação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “Árvores de decisão: teoria e implementação”?
Impureza de Gini, ganho de informação, profundidade da árvore e sobreajuste — DecisionTreeClassifier do sklearn. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Árvores de decisão: teoria e implementação”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Árvores de decisão: teoria e implementação
- Florestas aleatórias e bagging
- Gradient Boosting: GBM e XGBoost
- LightGBM e CatBoost