Florestas aleatórias e bagging
Conceito de conjunto, RandomForestClassifier, n_estimators, importância dos atributos e pontuação OOB.
Florestas aleatórias e bagging é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 2 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 problema das árvores individuais
Uma única árvore de decisão tem alta variância: treiná-la novamente com dados ligeiramente diferentes pode produzir uma árvore muito diferente. Os métodos de conjunto resolvem isso combinando muitas árvores.
Bagging (agregação por reamostragem)
Bagging treina muitos modelos com diferentes amostras de reamostragem (amostragem aleatória com reposição) dos dados e depois calcula a média de suas previsões.
Calcular a média de muitos modelos de alta variância reduz a variância geral sem aumentar muito o viés.
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
bag = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=100,
random_state=0,
)
bag.fit(Xtr, ytr)Do Bagging às florestas aleatórias
Uma floresta aleatória aplica bagging a árvores e acrescenta um truque: em cada divisão, considera apenas um subconjunto aleatório de características.
Isso torna as árvores menos correlacionadas, fazendo com que seus erros se anulem melhor e melhorando o conjunto.
Fundamentos de RandomForestClassifier
Use RandomForestClassifier. O parâmetro principal, n_estimators, define quantas árvores serão construídas. Mais árvores = mais estabilidade, mas menor velocidade.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, random_state=0)
rf.fit(Xtr, ytr)
print("Accuracy:", rf.score(Xte, yte))Treinamento paralelo com n_jobs
As árvores de uma floresta são independentes, portanto são treinadas em paralelo. Defina n_jobs=-1 para usar todos os núcleos da CPU e acelerar bastante o ajuste.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=500,
n_jobs=-1, # use all cores
random_state=0,
)
rf.fit(Xtr, ytr)Score OOB (fora da amostra)
Cada árvore deixa de fora cerca de um terço das amostras (a reamostragem não as selecionou). Essas amostras fora da amostra formam um conjunto de validação integrado.
Defina oob_score=True para obter uma estimativa gratuita do erro de generalização, sem uma divisão separada.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
oob_score=True,
random_state=0,
)
rf.fit(Xtr, ytr)
print("OOB score:", rf.oob_score_)Controlando a profundidade das árvores na floresta
Os mesmos parâmetros de árvore se aplicam: max_depth, min_samples_leaf e max_features (quantas características testar por divisão).
max_features="sqrt" é o padrão comum para classificação.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
max_depth=12,
max_features="sqrt",
random_state=0,
)Importâncias das características integradas
Assim como as árvores individuais, as florestas expõem feature_importances_, calculadas como a média de todas as árvores. Essa importância baseada na impureza é rápida, mas pode favorecer características com alta cardinalidade.
from sklearn.ensemble import RandomForestClassifier
import numpy as np
rf = RandomForestClassifier(n_estimators=200, random_state=0).fit(Xtr, ytr)
order = np.argsort(rf.feature_importances_)[::-1]
for i in order[:5]:
print(i, rf.feature_importances_[i])Importância por permutação
Importância por permutação é mais confiável: ela embaralha uma coluna de características e mede quanto o score diminui. Uma grande diminuição significa que a característica era importante.
Ela é independente do modelo e evita o viés da impureza.
from sklearn.inspection import permutation_importance
result = permutation_importance(
rf, Xte, yte, n_repeats=10, random_state=0, n_jobs=-1
)
print(result.importances_mean)Interpretando os resultados da permutação
permutation_importance retorna importances_mean e importances_std entre as repetições. Calcule-a em um conjunto separado para avaliação para medir o impacto na generalização, não no ajuste do treinamento.
import numpy as np
means = result.importances_mean
stds = result.importances_std
for i in np.argsort(means)[::-1]:
print(f"feature {i}: {means[i]:.3f} +/- {stds[i]:.3f}")Quando usar florestas aleatórias
As florestas aleatórias são uma excelente opção padrão: robustas, exigem poucos ajustes, lidam com não linearidades e interações e resistem ao ajuste excessivo. As desvantagens são o maior consumo de memória, a previsão mais lenta que a de uma única árvore e a menor interpretabilidade.
Verificação rápida
Verifique sua compreensão sobre bagging e florestas.
Recapitulação
Recapitulação: o Bagging treina modelos com amostras de reamostragem e calcula a média entre eles para reduzir a variância. As florestas aleatórias acrescentam subconjuntos aleatórios de características em cada divisão. Ajuste usando n_estimators, use n_jobs=-1 para obter mais velocidade, obtenha validação sem custo adicional por meio de oob_score e prefira permutation_importance à importância baseada na impureza para obter classificações confiáveis.
Perguntas Frequentes
A aula “Florestas aleatórias e bagging” é grátis?
Sim — o texto completo de “Florestas aleatórias e bagging” é 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 “Florestas aleatórias e bagging”?
Conceito de conjunto, RandomForestClassifier, n_estimators, importância dos atributos e pontuação OOB. 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 2 de 4.
Quanto tempo leva a aula “Florestas aleatórias e bagging”?
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