AdaBoost: machine learning fácil e com ótimo desempenho

Posts Relacionados:

IA em Python com regressão logística

Conheça o kNN, um algoritmo intuitivo e versátil

Machine learning descomplicada com a biblioteca scikit-learn

17.09.24

AdaBoost é um dos algoritmos mais famosos entre as técnicas de boosting em machine learning. Fácil de implementar, simples de compreender e com bom desempenho, ele é a escolha certa para muitas aplicações.

Receba nossa newsletter

Boosting em machine learning

Em machine learning, boosting é uma técnica de aprendizado em conjunto. Um conjunto é um modelo composto. Ele combina uma série de classificadores (ou alunos) fracos para criar um classificador aprimorado. Se o desempenho de cada classificador fraco for melhor do que a adivinhação aleatória, o modelo final poderá ser um modelo forte.

Existem três grupos principais de aprendizado de conjunto: bagging, stacking e boosting.

Esquema mostrando as diferenças entre um classificador único e duas técnicas de aprendizado de conjunto: o bagging e o boosting. No boosting, vários modelos são treinados em sequência (fonte).

Na prática, algoritmos de boosting atuam treinando modelos em sequência a partir dos dados de treinamento. Cada modelo da sequência é desenvolvido para corrigir os erros do modelo anterior.

Entre os algoritmos de boosting mais populares estão o Gradient Boosting, o XGBoost (Extreme Gradient Boosting) e o AdaBoost (Adaptive Boosting). Neste post, nos concentraremos no AdaBoost.

AdaBoost (Adaptative Boosting)

O AdaBoost foi o primeiro algoritmo de aprendizado de conjuntos realmente bem-sucedido. Desenvolvido em 1995 por Yoav Freund e Robert Schapire, ele se popularizou rapidamente. Ele foi desenvolvido para classificação binária, mas pode ser aplicado facilmente para problemas multi-classes.

O funcionamento do AdaBoost é simples de se entender. Ele treina iterativamente alunos fracos e ajusta seus pesos com base em seus desempenhos. Como é um algoritmo de boosting, ele treina vários alunos em sequência.

No início do treinamento, cada instância dos dados de treino recebe um peso igual. Um aluno (modelo) fraco é treinado no conjunto de dados. Os pesos das instâncias de treinamento são ajustados com base no desempenho do aluno. As instâncias em que o aluno classificou incorretamente recebem pesos mais altos. As instâncias classificadas corretamente recebem pesos mais baixos. Em seguida, o algoritmo usa as instâncias ponderadas para treinar o próximo modelo da sequência. Os modelos são adicionados em sequência até que o desempenho se estabilize ou um número máximo de modelos seja atingido.

O AdaBoost é adaptável no sentido de que os alunos fracos subsequentes são treinados enfatizando as instâncias classificadas incorretamente pelos alunos anteriores. O algoritmo se concentra em exemplos difíceis, atribuindo pesos mais altos para as instâncias classificadas incorretamente pelos alunos anteriores.

Esquema geral do funcionamento do AdaBoost (modificado a partir daqui).

Árvores de decisão como alunos fracos

O AdaBoost pode ser usado para aumentar o desempenho de qualquer algoritmo de machine learning. Porém, o algoritmo mais comumente usado como aluno fraco do AdaBoost são as árvores de decisão com um nível. Como essas árvores são curtas e contêm apenas uma decisão para classificação, elas são frequentemente chamadas de tocos de decisão (decision stumps).

AdaBoost na prática

Para exemplificar como é simples implementar o AdaBoost, faremos um exemplo usando Scikit-learn. Classificaremos o conjunto de dados iris. A implementação do modelo segue as etapas tradicionais de um algoritmo de aprendizagem supervisionada de machine learning. As etapas são: carregamento dos dados, separação dos atributos e rótulos, separação de conjuntos de treino e teste, treino do modelo e verificação de seu desempenho. Em código, isso pode ser definido assim:

				
					from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Correga os dados
iris = load_iris()  

# separa atributos (X) e classes (y)
X = iris.data
y = iris.target

# Divide os dados
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Cria o classificador
clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1), n_estimators=100)

# Treina o modelo
clf.fit(X_train, y_train)

# Realiza predições no conjunto de teste
y_pred = clf.predict(X_test)

# Verifica acurácia
accuracy = accuracy_score(y_test, y_pred)
print("Acurácia:", round(accuracy*100, 3), "%")
# Acurácia: 93.333 %

Os parâmetros mais importantes dessa implementação ocorrem na linha 18. Eles são estimator e n_estimators. O estimator é o aluno fraco. Neste exemplo, usamos DecisionTreeClassifier (árvore de decisão). O parâmetro n_estimators se refere ao número de alunos fracos que serão treinados iterativamente. Usamos 100. Para conhecer outros parâmetros opcionais, consulte esse link.

Para terminar

O AdaBoost é um algoritmo de machine learning com inúmeras vantagens. Ele é fácil de implementar. Seu funcionamento é de simples compreensão. Ele corrige iterativamente os erros de classificadores fracos para obter um classificador forte. Embora ele seja comumente implementado usando árvores de decisão como classificadores de base, você pode usar outros classificadores. Esse post tem um exemplo de implementação usando máquinas de vetores de suporte. O AdaBoost também não é propenso a overfitting.

Apesar de todas essas vantagens, o AdaBoost tem algumas desvantagens importantes. Ele é muito sensível à qualidade dos dados de treino. Outliers e dados com qualidade baixa comprometem muito seu desempenho. Ele também é sensível a dados com muito ruído. Portanto, o uso do AdaBoost em projetos deve levar em conta esses pontos.