AdaBoost Classifier em Python

Nos últimos anos, algoritmos de boosting ganharam enorme popularidade em competições de ciência de dados e machine learning. A maioria dos vencedores usa boosting para alcançar alta precisão. Essas competições oferecem um palco global para aprender, explorar e propor soluções para problemas de negócios e do setor público. Algoritmos de boosting combinam vários modelos de baixa precisão (ou fracos) para criar modelos de alta precisão (ou fortes). Eles podem ser aplicados em várias áreas, como crédito, seguros, marketing e vendas. Algoritmos como AdaBoost, Gradient Boosting e XGBoost são amplamente usados para vencer competições de ciência de dados. Neste tutorial, você vai aprender o algoritmo de ensemble AdaBoost, e vamos abordar os seguintes tópicos:

• Abordagem de ensemble em machine learning
  • Bagging
  • Boosting
  • Stacking
• Classificador AdaBoost
• Como o algoritmo AdaBoost funciona?
• Construindo o modelo em Python
• Prós e contras
• Conclusão

Abordagem de ensemble em machine learning

Um ensemble é um modelo composto que combina uma série de classificadores de baixo desempenho para criar um classificador melhor. Aqui, cada classificador individual vota e a predição final retorna o rótulo com maioria de votos. Ensembles costumam entregar mais acurácia do que um classificador isolado (base). Métodos de ensemble podem ser paralelizados alocando cada aprendiz base em máquinas diferentes. Em resumo, métodos de ensemble são meta-algoritmos que combinam vários métodos de machine learning em um único modelo preditivo para aumentar a performance. Eles podem reduzir a variância com bagging, reduzir o viés com boosting ou melhorar as predições com stacking.

1. Bagging vem de bootstrap aggregation. Ele combina vários aprendizes para reduzir a variância das estimativas. Por exemplo, Random Forest treina M árvores de decisão: você treina M árvores diferentes em subconjuntos aleatórios dos dados e realiza votação para a predição final. Métodos de bagging incluem Random Forest e Extra Trees.

2. Algoritmos de boosting combinam classificadores de baixa acurácia para criar um classificador de alta acurácia. Um classificador fraco oferece acurácia apenas um pouco melhor que lançar uma moeda. Um classificador forte apresenta taxa de erro próxima de 0. O boosting consegue dar mais foco aos casos onde o modelo falhou na predição. Em geral, é menos suscetível a overfitting. Os três algoritmos abaixo são muito populares em competições:

   • AdaBoost (Adaptive Boosting)
   • Gradient Tree Boosting
   • XGBoost

3. Stacking (ou stacked generalization) é uma técnica de ensemble que combina as predições de múltiplos modelos base em um novo conjunto de dados. Esse novo conjunto serve de entrada para outro classificador, que é usado para resolver o problema. Stacking também é conhecido como blending.

Com base no arranjo dos aprendizes base, métodos de ensemble podem ser divididos em dois grupos: paralelos, nos quais os aprendizes base são gerados em paralelo (por exemplo, Random Forest), e sequenciais, nos quais eles são gerados em sequência (por exemplo, AdaBoost).

Com base no tipo de aprendizes base, métodos de ensemble podem ser divididos em: homogêneos, quando usam o mesmo tipo de aprendiz base em cada iteração, e heterogêneos, quando usam tipos diferentes a cada iteração.

Classificador AdaBoost

AdaBoost, ou Adaptive Boosting, é um classificador de ensemble proposto por Yoav Freund e Robert Schapire em 1996. Ele combina múltiplos classificadores para aumentar a acurácia. O AdaBoost é um método iterativo que constrói um classificador forte ao combinar vários classificadores de baixo desempenho, resultando em alta precisão. A ideia central é ajustar os pesos dos classificadores e das amostras de treino em cada iteração para garantir melhores predições de observações incomuns. Qualquer algoritmo de machine learning pode ser usado como classificador base, desde que aceite pesos no conjunto de treino. O AdaBoost deve atender a duas condições:

1. O classificador deve ser treinado iterativamente em exemplos de treino ponderados de formas diferentes.
2. Em cada iteração, ele tenta se ajustar bem a esses exemplos, minimizando o erro de treino.

Como o algoritmo AdaBoost funciona?

Ele segue os passos abaixo:

1. Inicialmente, o AdaBoost seleciona um subconjunto de treino aleatoriamente.
2. Ele treina o modelo de forma iterativa, escolhendo o conjunto de treino com base na acurácia obtida na última iteração.
3. Atribui maior peso às observações classificadas incorretamente para que, na próxima iteração, elas tenham maior probabilidade de serem corretamente classificadas.
4. Também atribui um peso ao classificador treinado em cada iteração de acordo com sua acurácia. Quanto mais preciso o classificador, maior o peso.
5. Esse processo se repete até que todo o conjunto de treino seja ajustado sem erro ou até atingir o número máximo de estimadores especificado.
6. Para classificar, realize uma "votação" entre todos os algoritmos que você treinou.

Construindo o modelo em Python

Importando as bibliotecas necessárias

Vamos carregar primeiro as bibliotecas necessárias.

# Load libraries
from sklearn.ensemble import AdaBoostClassifier
from sklearn import datasets
# Import train_test_split function
from sklearn.model_selection import train_test_split
#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics

Carregando o dataset

Para construir o modelo, vamos usar o dataset IRIS, um problema clássico de classificação multiclasse. Esse conjunto tem 4 features (sepal length, sepal width, petal length, petal width) e um alvo (o tipo de flor). Existem três classes de flores: Setosa, Versicolour e Virginica. O dataset está disponível na biblioteca scikit-learn, e você também pode baixá-lo do UCI Machine Learning Repository.

# Load data
iris = datasets.load_iris()
X = iris.data
y = iris.target

Dividindo o dataset

Para avaliar o desempenho do modelo, é uma boa prática dividir o conjunto em treino e teste.

Vamos usar a função train_test_split(). Você precisa passar 3 parâmetros: features, target e o tamanho do conjunto de teste.

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # 70% training and 30% test

Construindo o modelo AdaBoost

Vamos criar o modelo AdaBoost com o Scikit-learn. Por padrão, o AdaBoost usa DecisionTreeClassifier como classificador base.

# Create adaboost classifer object
abc = AdaBoostClassifier(n_estimators=50,
                         learning_rate=1)
# Train Adaboost Classifer
model = abc.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = model.predict(X_test)

"Os parâmetros mais importantes são base_estimator, n_estimators e learning_rate." (Adaboost Classifier, Chris Albon)

• base_estimator: é o aprendiz fraco usado para treinar o modelo. Por padrão, usa DecisionTreeClassifier como aprendiz fraco. Você pode especificar outros algoritmos de machine learning.
• n_estimators: número de aprendizes fracos a serem treinados iterativamente.
• learning_rate: controla os pesos dos aprendizes fracos. O padrão é 1.

Avaliando o modelo

Vamos estimar com que precisão o classificador consegue prever o tipo de flor.

A acurácia pode ser calculada comparando os valores reais do conjunto de teste com os valores preditos.

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

Accuracy: 0.8888888888888888

Você obteve uma acurácia de 88,88%, considerada boa.

Para aprofundar a avaliação, você também pode criar um modelo usando diferentes estimadores base.

Usando diferentes aprendizes base

Aqui usei SVC como estimador base. Você pode usar qualquer algoritmo que aceite pesos de amostra, como Decision Tree ou Support Vector Classifier.

# Load libraries
from sklearn.ensemble import AdaBoostClassifier

# Import Support Vector Classifier
from sklearn.svm import SVC
#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics
svc=SVC(probability=True, kernel='linear')

# Create adaboost classifer object
abc =AdaBoostClassifier(n_estimators=50, base_estimator=svc,learning_rate=1)

# Train Adaboost Classifer
model = abc.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = model.predict(X_test)


# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

Accuracy: 0.9555555555555556

Neste caso, você obteve uma taxa de acerto de 95,55%, considerada muito boa.

Aqui, o SVC como estimador base atingiu melhor acurácia do que o Decision Tree como estimador base.

Prós

O AdaBoost é simples de implementar. Ele corrige iterativamente os erros do classificador fraco e melhora a acurácia ao combinar aprendizes fracos. Você pode usar vários classificadores base com o AdaBoost. Em geral, não é tão propenso a overfitting. Isso é observado empiricamente, embora não haja um motivo teórico único e definitivo.

Contras

O AdaBoost é sensível a dados com ruído. É bastante afetado por outliers, pois tenta ajustar perfeitamente cada ponto. Também costuma ser mais lento que o XGBoost.

Conclusão

Parabéns por chegar ao fim deste tutorial!

Nele, você aprendeu sobre abordagens de ensemble, o algoritmo AdaBoost, como ele funciona, e como construir e avaliar o modelo usando o pacote Scikit-learn em Python. Também discutimos seus prós e contras.

Fico no aguardo de dúvidas e feedback. Deixe um comentário com sua pergunta e vou fazer o possível para responder.

Se você quer aprender mais sobre machine learning em Python, confira os cursos da DataCamp Extreme Gradient Boosting with XGBoost e Python Machine Learning: Scikit-Learn Tutorial.