Tutorial de modelagem em ensemble: explore técnicas de aprendizado em conjunto

Modelos de machine learning não são como soluções tradicionais de software. Esses modelos precisam de atualizações constantes à medida que novos dados ficam disponíveis, para garantir previsões precisas e confiáveis. Em cenários complexos e sensíveis, depender de um único modelo pode não ser suficiente para gerar um resultado ideal — e é aí que o ensemble modeling entra em cena.

Este tutorial conceitual explica o que é modelagem em ensemble em machine learning e como ela pode melhorar o desempenho geral do seu modelo. Em seguida, apresentamos uma visão geral de vários métodos de ensemble antes de ilustrar um cenário do mundo real com uma implementação passo a passo em Python.

Nosso tutorial Ensemble learning em R com SuperLearner mostra como turbinar seus resultados em machine learning usando a abordagem de ensemble com o pacote SuperLearner em R.

Modelos de ensemble em machine learning

Imagine um empresário musical participando de uma competição internacional. Ele tem acesso a uma grande variedade de músicos com expertises diferentes:

• Músicos clássicos com habilidade para compor peças tradicionais.
• Músicos eletrônicos, especialistas em instrumentos eletrônicos.
• Músicos de jazz com grande senso de improvisação.
• Solistas que executam solos complexos e evidenciam sua técnica.

Diante desse amplo leque de experiências e formações, o empresário pode combinar todos eles para criar uma apresentação única e memorável.

Pense nos modelos de ensemble como uma orquestra, em que cada pessoa se especializa em um instrumento — piano, trompete, bateria e por aí vai. A combinação dessas habilidades cria uma melodia harmoniosa.

O aprendizado em ensemble segue a mesma lógica:

Ele combina vários algoritmos para obter um desempenho preditivo melhor do que o de um único modelo. Não existe um número pré-definido de modelos a considerar; alguns objetivos de negócio podem exigir mais modelos do que outros.

Erro do modelo e como reduzi-lo com ensembles

O erro de qualquer modelo pode ser decomposto matematicamente em três componentes:

Viés + Variância + Erro irredutível

Por que isso é importante aqui? Para entender o que acontece por trás de um modelo de ensemble, você precisa primeiro saber o que causa erro no modelo.

Vamos ver esses erros:

Erro de viés

Serve para quantificar o quanto, em média, os valores previstos se afastam do valor real. Um viés alto indica um modelo com baixo desempenho, que deixa passar tendências essenciais.

Variância

Por outro lado, a variância quantifica quanto as previsões feitas sobre a mesma observação diferem entre si. Um modelo com alta variância tende a overfitting no conjunto de treino e a performar mal em observações fora do treino. O diagrama a seguir ajuda a visualizar isso (considere que o ponto vermelho é o valor real e os pontos azuis são as previsões):

Geralmente, ao aumentar a complexidade do seu modelo, o erro diminui devido à redução do viés. Porém, isso só vai até certo ponto. Continuando a aumentar a complexidade, você acaba fazendo overfitting e o modelo passa a sofrer com alta variância.

Agora que você já conhece o básico de ensemble learning, vamos ver diferentes técnicas:

Tipos de métodos de ensemble

Há diferentes tipos de métodos de ensemble, cada um com vantagens e desvantagens. Esta seção cobre esses aspectos para ajudar você a fazer a melhor escolha para seus casos de uso.

Antes de entrar em cada método, vale entender o que são meta learners e base learners, para facilitar os próximos conceitos.

• Base learners são o primeiro nível de uma arquitetura de ensemble learning, e cada um é treinado para fazer previsões individuais.
• Meta learners, por sua vez, ficam no segundo nível e são treinados a partir da saída dos base learners.

Bagging

Bagging também é conhecido como bootstrap aggregation. Essa técnica é semelhante ao random forest, mas usa todos os preditores, enquanto random forest usa apenas um subconjunto de preditores em cada árvore.

No bagging, uma amostra aleatória do conjunto de treino é selecionada com reposição, o que permite a duplicação de instâncias. Os passos principais são:

• Gerar várias amostras bootstrap.
• Executar um algoritmo em cada amostra para gerar previsões.
• Combinar as previsões por média (para regressão) ou voto da maioria (para classificação).

O bagging apresenta várias vantagens e desvantagens importantes em tarefas de classificação ou regressão.

Vantagens

• O processo de modelagem é direto, não exige conceitos matemáticos profundos e lida com valores ausentes.
• O scikit-learn facilita a implementação da lógica. Ele traz módulos para combinar as previsões de cada modelo (os base learners).
• Reduz significativamente a variância em classificadores de alta variância. Isso é útil com dados de alta dimensionalidade, evitando que o modelo perca capacidade de generalização.
• Fornece uma estimativa não tendenciosa do erro out-of-bag, que corresponde ao erro/perda médio gerado por todos os classificadores.

Desvantagens

• É computacionalmente custoso devido ao uso de vários modelos.
• A média entre previsões dificulta a interpretação do resultado final.

Boosting

O boosting adota uma abordagem sequencial, em que a previsão do modelo atual é passada para o próximo. Cada modelo foca iterativamente nas observações classificadas de forma incorreta pelos anteriores. O processo geral é o seguinte:

Vantagens

• Assim como o bagging, o boosting é fácil de entender e implementar. Além disso, não requer pré-processamento e lida com valores ausentes.
• Reduz o viés com eficiência.
• Durante o treino, os algoritmos de boosting priorizam atributos que aumentam a acurácia geral. Isso reduz a dimensionalidade dos dados e, consequentemente, o tempo de computação.

Desvantagens

• Por ser sequencial, cada modelo corrige os erros do anterior, deixando o conjunto mais vulnerável a outliers.
• Pela mesma razão, o boosting tem menor escalabilidade.

Stacking

O stacking é bem parecido com o boosting. As previsões dos base learners são empilhadas e usadas como entrada para treinar o meta learner, gerando previsões mais robustas. Depois, o meta learner é usado para as previsões finais. Bagging e boosting costumam usar base learners homogêneos, enquanto o stacking tende a incluir modelos heterogêneos.

Vantagens

• Aproveita os pontos fortes de vários modelos de alto desempenho em tarefas de classificação e regressão.
• Assim como outros ensembles, o stacking ajuda a construir um modelo mais preciso do que modelos individuais usados isoladamente.

Desvantagens

• Usar modelos básicos complexos pode aumentar o risco de overfitting.
• Os diferentes níveis de treino podem tornar a arquitetura de stacking complexa de implementar.

Blending

O blending é semelhante ao stacking. No blending, a estrutura dos dados envolve conjuntos de treino, hold-out e teste. Os meta learners são treinados nos dados de treino. Depois, suas previsões são combinadas com o conjunto hold-out para construir o meta modelo final, que usa os dados de teste para gerar as previsões finais.

Vantagens

• Como o stacking e outros métodos de ensemble, o blending pode aumentar o desempenho do modelo final em muitos casos.
• Essa técnica já foi decisiva na vitória em várias competições.

Desvantagens

• Dividir os dados originais conforme a arquitetura de blending pode limitar os dados disponíveis para treinar os base models, levando a desempenho inferior.
• Assim como em outros ensembles, a interpretabilidade do modelo final diminui devido à complexidade, dificultando extrair insights de negócio.

Voting

No voting, vários modelos são treinados de forma independente e suas previsões são combinadas para gerar a previsão final usando hard voting, soft voting ou weighted voting:

• No hard voting, a previsão final é a mais comum entre todos os modelos.
• No soft voting, cada modelo gera uma distribuição de probabilidades em vez de uma previsão binária. A classe com maior probabilidade é a prevista.
• Por fim, no weighted voting, assume-se que alguns modelos têm mais habilidade que outros, e eles recebem maior peso na agregação das previsões.

Vantagens

• A arquitetura de voting é mais simples de implementar do que stacking e blending. Também não exige ajustes finos complexos.
• Usar vários base learners torna o voting menos suscetível à influência de modelos individuais, gerando previsões mais estáveis e confiáveis.

Desvantagens

• Conflitos entre previsões dos modelos podem ser difíceis de resolver, o que complica a decisão final.
• Adicionar mais modelos ao ensemble de voting não garante melhoria de desempenho.

Cascading

O cascading usa uma abordagem de stacking, mas com apenas um modelo em cada camada. O primeiro modelo é treinado com todo o conjunto de treino, e o seguinte é treinado na saída do anterior. O objetivo é aprender padrões complexos nos dados, permitindo previsões melhores.

Vantagens

• O próximo modelo se especializa na saída do anterior, reduzindo ruído nos dados.
• É mais robusto a overfitting e pode performar bem em dados do mundo real.

Desvantagens

• Implementar cascading pode ser complexo, já que envolve treinar cada modelo na sequência.
• Encontrar a arquitetura ideal pode exigir muita experimentação e ajustes.

Visão geral de algoritmos de ensemble

As seções anteriores cobriram os diferentes tipos de modelos de ensemble. Agora, vamos ver rapidamente alguns modelos populares.

Random forest

Random forest é um modelo amplamente usado que resolve problemas de classificação e regressão. Uma random forest é composta por muitas árvores de decisão treinadas via bagging. O resultado é determinado pela média das previsões das árvores individuais.

Tamanho do nó, número de árvores e número de atributos amostrados são os três principais hiperparâmetros a serem definidos antes do treino.

E a aleatoriedade na random forest?

O feature bagging, também chamado de aleatoriedade de atributos, cria uma amostra aleatória de variáveis para garantir baixa correlação entre as árvores. Essa abordagem diferencia as random forests das árvores de decisão tradicionais, que consideram todas as possíveis divisões de atributos, enquanto as random forests consideram apenas um subconjunto. Leia mais no nosso tutorial de classificação com random forest.

XGBoost

Extreme Gradient Boosting, ou XGBoost, é usado tanto para classificação quanto para regressão. O XGBoost foi projetado para ser escalável e altamente eficiente, implementando o framework de árvores de decisão com gradient boosting.

Ele é adequado para processar conjuntos de dados em grande escala e é compatível com principais ambientes distribuídos, como Hadoop, MPI (Message Passing Inference) e SGI (Sun Grid Engine). Você pode aprender mais no nosso tutorial de XGBoost.

AdaBoost

Adaptive Boosting, ou AdaBoost, é um dos primeiros classificadores de boosting bem-sucedidos para classificação binária. Ele é adaptativo porque os pesos são reatribuídos a cada instância, dando pesos maiores às instâncias classificadas erroneamente. Saiba mais em Classificação com AdaBoost em Python no nosso tutorial dedicado.

Implementação passo a passo de modelos de ensemble

Agora que você entendeu a ideia por trás da modelagem em ensemble e como alguns modelos funcionam, vamos focar na implementação técnica em Python.

Configurando o ambiente

Para começar, você precisa ter o Python instalado no seu computador, além das seguintes bibliotecas:

• pandas para carregar o data frame.
• Scikit-learn para usar algoritmos de machine learning já existentes.
• Seaborn e matplotlib para visualização.

Você pode instalar essas bibliotecas com o pip, o gerenciador de pacotes do Python, assim:

pip install scikit-learn
pip install pandas
pip install matplotlib seaborn

Para ilustrar o caso de uso, vamos utilizar o conjunto Loan Data disponível no DataLab. O código deste tutorial também está no DataLab, neste workbook; você pode criar uma cópia, editar e executar o código no navegador sem instalar nada no seu computador.

Entendendo os dados

O conjunto tem 9.500 empréstimos com informações sobre a estrutura do empréstimo, o tomador e se o empréstimo foi quitado, representado pela coluna not.fully.paid. As cinco primeiras observações são mostradas abaixo:

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()

Usando a função info() obtemos as seguintes informações relevantes:

• 9.578 linhas (de 0 a 9577) e 14 colunas de tipos numéricos, exceto purpose, que é object e traz a descrição textual do propósito do empréstimo.
• A tag non-null em cada coluna indica que não há valores ausentes naquela coluna.

loan_data.info()

Percebemos um cenário de desbalanceamento, com muito mais observações da classe 0 (8045) do que da classe 1 (apenas 1533).

print(loan_data['not.fully.paid'].value_counts())
loan_data['not.fully.paid'].value_counts().plot(kind='barh')

Treinar modelos com dados tão desbalanceados afeta o desempenho geral.

Uma forma de lidar com isso é a subamostragem (undersampling), ou seja, reduzir o número de observações da classe majoritária (classe 0). Nesse cenário, teremos tantas observações da classe 0 quanto da classe 1. O processo é:

• Primeiro, obter o número de observações da classe 1.

• Selecionar N observações aleatórias da classe 0, onde N é o tamanho do dataframe da classe 1.

• Concatenar os dois dataframes.

loan_data_class_1 = loan_data[loan_data['not.fully.paid'] == 1]
number_class_1 = len(loan_data_class_1)
loan_data_class_0 = loan_data[loan_data['not.fully.paid'] == 0].sample(number_class_1)

final_loan_data = pd.concat([loan_data_class_1,
                         	loan_data_class_0])

print(final_loan_data.shape)

O tutorial Aprofundando em dados desbalanceados traz mais técnicas para tratar conjuntos desequilibrados.

Após o undersampling, obtemos:

• No total, 3066 observações e 14 colunas.

E a distribuição final balanceada é mostrada abaixo.

Preparando os dados para treino

Observando o conjunto, percebemos que nem todos os atributos estão na mesma escala, e alguns modelos, como KNN, são sensíveis a isso. Podemos resolver normalizando as variáveis para a mesma escala com o módulo MinMaxScaler — neste caso, entre 0 e 1.

Também vamos remover a coluna purpose para simplificar, pois ela requer pré-processamento adicional.

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

# Remover a coluna 'purpose' e obter os dados
final_loan_data.drop('purpose', axis=1, inplace=True)
X = final_loan_data.drop('not.fully.paid', axis=1)

normalized_X = scaler.fit_transform(X)

Como em qualquer tarefa preditiva, precisamos dividir os dados em treino e teste. Aqui, usaremos 77% para treino e 33% para teste.

• O random_state é inicializado com um valor fixo (2023 no nosso caso) para garantir reprodutibilidade.

Stratify é usado para garantir que o alvo y fique igualmente distribuído nos dados de treino e de teste.

from sklearn.model_selection import train_test_split

y = final_loan_data['not.fully.paid']
r_state = 2023
t_size = 0.33

X_train, X_test, y_train, y_test = train_test_split(normalized_X, y,
                                                	test_size=t_size,
                                                	random_state=r_state,
                                                	stratify=y)

Todos os modelos seguirão a sequência: treinar nos dados de treino, prever nos dados de teste e avaliar o desempenho.

Modelo de bagging

Usaremos Random forest como modelo de bagging nesta seção. Vamos manter os parâmetros padrão para simplificar.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# Definir o modelo
random_forest_model = RandomForestClassifier()
# Ajustar o modelo
random_forest_model.fit(X_train, y_train)

Depois do treino, medimos o desempenho com a função accuracy_score assim:

# Fazer previsões
y_pred = random_forest_model.predict(X_test)

# Obter o desempenho
accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy) 

O print acima retorna 0.6156, ou seja, 61,56%.

Agora vamos comparar esse resultado com a performance de uma abordagem de blending.

Modelo de blending

Para o blending, usaremos dois modelos base: uma árvore de decisão e um classificador K-Nearest Neighbors. Um modelo final de regressão logística fará as previsões finais.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

Os dados originais de treino são divididos em um novo conjunto de treino e um de validação. Os modelos base são treinados nos dados de treino.

X_train, X_val, y_train, y_val = train_test_split(
                                            	X_train, y_train,
                                            	test_size=t_size,
                                            	random_state=r_state)

Em seguida, geramos dois dataframes a partir das previsões desses modelos base:

• Primeiro dataframe com as previsões sobre os dados de validação concatenadas aos dados originais de validação.
• Segundo dataframe com as previsões sobre os dados de teste concatenadas aos dados originais de teste.

# Modelo de árvore de decisão
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_model_pred_val = dt_model.predict(X_val)
dt_model_pred_test= dt_model.predict(X_test)

dt_model_pred_val = pd.DataFrame(dt_model_pred_val)
dt_model_pred_test = pd.DataFrame(dt_model_pred_test)

# Modelo KNN
knn_model = KNeighborsClassifier()
knn_model.fit(X_train,y_train)
knn_model_pred_val = knn_model.predict(X_val)
knn_model_pred_test = knn_model.predict(X_test)

knn_model_pred_val = pd.DataFrame(knn_model_pred_val)
knn_model_pred_test = pd.DataFrame(knn_model_pred_test)

O modelo final de regressão logística é construído usando os dados concatenados de validação e avaliado com os dados concatenados de teste.

x_val = pd.DataFrame(X_val)
x_test = pd.DataFrame(X_test)

df_val_lr = pd.concat([x_val, knn_model_pred_val,
                    	dt_model_pred_val], axis=1)

df_test_lr = pd.concat([x_test, dt_model_pred_test,
                     	knn_model_pred_test],axis=1)

# Modelo de regressão logística
lr_model = LogisticRegression()

lr_model.fit(df_val_lr,y_val)
lr_model.score(df_test_lr,y_test)

Usando .score(), a acurácia é calculada por padrão, sem precisar gerar previsões explicitamente.

O resultado é 0.6383, ou 63,83%, cerca de 2% acima da random forest inicial; portanto, o modelo de blending entregou o melhor desempenho.

Nossos cursos Ensemble methods em Python e Machine learning com modelos baseados em árvores em R são ótimos próximos passos para seguir sua jornada em machine learning e mergulhar no mundo dos classificadores em ensemble, respectivamente em Python e R.

Conclusão

Este artigo apresentou diferentes tipos de modelagem em ensemble, com suas características, vantagens e desvantagens. Também trouxe uma visão geral de alguns algoritmos baseados em ensemble, como Random forest, Adaboost, XGBoost, Gradient Boosting Trees e Gradient Boosting Machines.

Ao construir modelos de ensemble, é importante conhecer seus prós e contras para extrair melhores insights de negócio.

FAQs

Qual a diferença entre learners homogêneos e heterogêneos?

Learners homogêneos usam algoritmos e hiperparâmetros semelhantes. Random forest pode ser considerado um ensemble de learners homogêneos.

Os heterogêneos, por outro lado, usam algoritmos e hiperparâmetros diferentes. Random forest, rede neural e KNN podem compor um ensemble heterogêneo.

Quais as vantagens dos modelos de ensemble sobre modelos únicos?

Usar ensembles geralmente leva a previsões melhores do que um modelo único.

Qual a limitação dos modelos em ensemble?

Ensembles podem sofrer com falta de interpretabilidade — o conhecimento aprendido pode não ser compreensível para usuários finais.

Quando evitar o uso de modelos de ensemble?

Deve-se evitar ensembles quando se exige alta interpretabilidade, há poucos dados, existem restrições de tempo real ou o custo computacional é alto.

Quais são os principais tipos de métodos de ensemble em machine learning?

Bagging, boosting, stacking, voting, blending e cascading são os principais tipos.