Mestre das Técnicas de Conjunto em Aprendizado de Máquina: Um Mergulho Profundo em Classificadores de Votação e Conjuntos Manuais

No cenário em constante evolução do aprendizado de máquina, alcançar a performance ideal do modelo muitas vezes requer o uso de múltiplos algoritmos. É aqui que entram as técnicas de conjunto. Métodos de conjunto combinam as forças de vários modelos para fornecer previsões mais precisas e robustas do que qualquer modelo individual poderia alcançar por si só. Neste guia abrangente, exploraremos duas técnicas de conjunto fundamentais: Classificadores de Votação e Conjuntos Manuais. Vamos percorrer suas implementações usando a biblioteca scikit-learn do Python, complementadas por um exemplo prático utilizando um conjunto de dados meteorológicos do Kaggle.

Sumário

Introdução às Técnicas de Conjunto
Entendendo Classificadores de Votação
1. Votação Dura vs. Votação Suave
2. Implementando um Classificador de Votação em Python
Explorando Métodos de Conjunto Manual
1. Implementação Passo a Passo de Conjunto Manual
Implementação Prática: Previsão do Tempo
Conclusão

Introdução às Técnicas de Conjunto

Aprendizado de conjunto é um paradigma poderoso no aprendizado de máquina onde múltiplos modelos, frequentemente referidos como “aprendizes fracos”, são estrategicamente combinados para formar um “aprendiz forte”. A premissa fundamental é que, embora modelos individuais possam ter diferentes graus de precisão, sua sabedoria coletiva pode levar a um desempenho aprimorado, redução da variância e melhor generalização.

Por Que Usar Técnicas de Conjunto?

Melhoria da Precisão: Combinar múltiplos modelos frequentemente resulta em um desempenho preditivo melhor.
Redução do Overfitting: Conjuntos podem mitigar o overfitting equilibrando os vieses e as variâncias dos modelos individuais.
Versatilidade: Aplicável a diversos domínios e compatível com diferentes tipos de modelos.

Entendendo Classificadores de Votação

Um Classificador de Votação é um dos métodos de conjunto mais simples e eficazes. Ele combina as previsões de múltiplos modelos diferentes e retorna a classe que recebe a maioria dos votos.

Votação Dura vs. Votação Suave

Votação Dura: A previsão final é a moda das classes previstas por cada modelo. Essencialmente, cada modelo tem um voto igual, e a classe com mais votos vence.
Votação Suave: Em vez de depender apenas das classes previstas, a votação suave considera as probabilidades previstas de cada classe. A previsão final é baseada na soma das probabilidades, e a classe com a maior probabilidade agregada é escolhida.

Implementando um Classificador de Votação em Python

Vamos nos aprofundar em uma implementação prática usando a biblioteca scikit-learn do Python. Utilizaremos um conjunto de dados meteorológicos para prever se vai chover amanhã.

1. Importando Bibliotecas Necessárias

import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score, classification_report

import pandas as pd

import numpy as np

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.impute import SimpleImputer

from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.metrics import accuracy_score, classification_report

2. Carregamento e Pré-processamento de Dados

# Carregar o conjunto de dados
dados = pd.read_csv('weatherAUS - tiny.csv')

# Exibir as últimas linhas
print(dados.tail())

# Carregar o conjunto de dados

dados = pd.read_csv('weatherAUS - tiny.csv')

# Exibir as últimas linhas

print(dados.tail())

3. Lidando com Dados Faltantes

# Separar características e alvo
X = dados.iloc[:, :-1]
y = dados.iloc[:, -1]

# Colunas numéricas
colunas_numericas = X.select_dtypes(include=['int64', 'float64']).columns
imputador_num = SimpleImputer(strategy='mean')
X[colunas_numericas] = imputador_num.fit_transform(X[colunas_numericas])

# Colunas categóricas
colunas_categoricas = X.select_dtypes(include=['object']).columns
imputador_cat = SimpleImputer(strategy='most_frequent')
X[colunas_categoricas] = imputador_cat.fit_transform(X[colunas_categoricas])

# Separar características e alvo

X = dados.iloc[:, :-1]

y = dados.iloc[:, -1]

# Colunas numéricas

colunas_numericas = X.select_dtypes(include=['int64', 'float64']).columns

imputador_num = SimpleImputer(strategy='mean')

X[colunas_numericas] = imputador_num.fit_transform(X[colunas_numericas])

# Colunas categóricas

colunas_categoricas = X.select_dtypes(include=['object']).columns

imputador_cat = SimpleImputer(strategy='most_frequent')

X[colunas_categoricas] = imputador_cat.fit_transform(X[colunas_categoricas])

4. Codificação de Variáveis Categóricas

# Codificação One-Hot
codificador = OneHotEncoder(drop='first', sparse=False)
colunas_codificadas = codificador.fit_transform(X[colunas_categoricas])
nomes_colunas_codificadas = codificador.get_feature_names_out(colunas_categoricas)
X_codificado = pd.DataFrame(colunas_codificadas, columns=nomes_colunas_codificadas)

# Combinar com características numéricas
X = pd.concat([X[colunas_numericas], X_codificado], axis=1)

# Codificação One-Hot

codificador = OneHotEncoder(drop='first', sparse=False)

colunas_codificadas = codificador.fit_transform(X[colunas_categoricas])

nomes_colunas_codificadas = codificador.get_feature_names_out(colunas_categoricas)

X_codificado = pd.DataFrame(colunas_codificadas, columns=nomes_colunas_codificadas)

# Combinar com características numéricas

X = pd.concat([X[colunas_numericas], X_codificado], axis=1)

5. Seleção de Características

# Escalonamento de Características
escalador = StandardScaler()
X_escalado = escalador.fit_transform(X)

# Selecionando as 5 principais características
selecionador = SelectKBest(score_func=chi2, k=5)
X_novo = selecionador.fit_transform(X_escalado, y)
caracteristicas_selecionadas = selecionador.get_support(indices=True)
nomes_caracteristicas = X.columns[caracteristicas_selecionadas]
print(f"Características Selecionadas: {nomes_caracteristicas}")

# Escalonamento de Características

escalador = StandardScaler()

X_escalado = escalador.fit_transform(X)

# Selecionando as 5 principais características

selecionador = SelectKBest(score_func=chi2, k=5)

X_novo = selecionador.fit_transform(X_escalado, y)

caracteristicas_selecionadas = selecionador.get_support(indices=True)

nomes_caracteristicas = X.columns[caracteristicas_selecionadas]

print(f"Características Selecionadas: {nomes_caracteristicas}")

6. Divisão de Treino e Teste

X_treino, X_teste, y_treino, y_teste = train_test_split(
    X_novo, y, test_size=0.20, random_state=1
)

X_treino, X_teste, y_treino, y_teste = train_test_split(

X_novo, y, test_size=0.20, random_state=1

)

7. Construindo Classificadores Individuais

from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb

# Inicializar modelos
knn = KNeighborsClassifier(n_neighbors=3)
lr = LogisticRegression(random_state=0, max_iter=200)
gnb = GaussianNB()
svc = SVC(probability=True)
dtc = DecisionTreeClassifier()
rfc = RandomForestClassifier(n_estimators=500, max_depth=5)
abc = AdaBoostClassifier()
xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')

from sklearn.neighbors import KNeighborsClassifier

from sklearn.linear_model import LogisticRegression

from sklearn.naive_bayes import GaussianNB

from sklearn.svm import SVC

from sklearn.tree import DecisionTreeClassifier

from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier

import xgboost as xgb

# Inicializar modelos

knn = KNeighborsClassifier(n_neighbors=3)

lr = LogisticRegression(random_state=0, max_iter=200)

gnb = GaussianNB()

svc = SVC(probability=True)

dtc = DecisionTreeClassifier()

rfc = RandomForestClassifier(n_estimators=500, max_depth=5)

abc = AdaBoostClassifier()

xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')

8. Treinando e Avaliando Modelos Individuais

# Lista de modelos e seus nomes
modelos = [
    ('KNN', knn),
    ('Regressão Logística', lr),
    ('GaussianNB', gnb),
    ('SVC', svc),
    ('Árvore de Decisão', dtc),
    ('Random Forest', rfc),
    ('AdaBoost', abc),
    ('XGBoost', xgb_model)
]

# Treinamento e avaliação
for nome, modelo in modelos:
    modelo.fit(X_treino, y_treino)
    y_pred = modelo.predict(X_teste)
    precisao = accuracy_score(y_pred, y_teste)
    print(f"{nome} Precisão: {precisao:.4f}")

# Lista de modelos e seus nomes

modelos = [

('KNN', knn),

('Regressão Logística', lr),

('GaussianNB', gnb),

('SVC', svc),

('Árvore de Decisão', dtc),

('Random Forest', rfc),

('AdaBoost', abc),

('XGBoost', xgb_model)

]

# Treinamento e avaliação

for nome, modelo in modelos:

modelo.fit(X_treino, y_treino)

y_pred = modelo.predict(X_teste)

precisao = accuracy_score(y_pred, y_teste)

print(f"{nome} Precisão: {precisao:.4f}")

Saída de Exemplo:

KNN Precisão: 0.8455
Regressão Logística Precisão: 0.8690
GaussianNB Precisão: 0.8220
SVC Precisão: 0.8700
Árvore de Decisão Precisão: 0.8345
Random Forest Precisão: 0.8720
AdaBoost Precisão: 0.8715
XGBoost Precisão: 0.8650

KNN Precisão: 0.8455

Regressão Logística Precisão: 0.8690

GaussianNB Precisão: 0.8220

SVC Precisão: 0.8700

Árvore de Decisão Precisão: 0.8345

Random Forest Precisão: 0.8720

AdaBoost Precisão: 0.8715

XGBoost Precisão: 0.8650

9. Implementando um Classificador de Votação

from sklearn.ensemble import VotingClassifier

# Inicializar Classificador de Votação com votação suave
classificador_votacao = VotingClassifier(
    estimators=[
        ('knn', knn),
        ('lr', lr),
        ('gnb', gnb),
        ('svc', svc),
        ('dtc', dtc),
        ('rfc', rfc),
        ('abc', abc),
        ('xgb', xgb_model)
    ],
    voting='soft'
)

# Treinar Classificador de Votação
classificador_votacao.fit(X_treino, y_treino)

# Prever e avaliar
y_pred_votacao = classificador_votacao.predict(X_teste)
precisao_votacao = accuracy_score(y_pred_votacao, y_teste)
print(f"Precisão do Classificador de Votação: {precisao_votacao:.4f}")

from sklearn.ensemble import VotingClassifier

# Inicializar Classificador de Votação com votação suave

classificador_votacao = VotingClassifier(

estimators=[

('knn', knn),

('lr', lr),

('gnb', gnb),

('svc', svc),

('dtc', dtc),

('rfc', rfc),

('abc', abc),

('xgb', xgb_model)

voting='soft'

)

# Treinar Classificador de Votação

classificador_votacao.fit(X_treino, y_treino)

# Prever e avaliar

y_pred_votacao = classificador_votacao.predict(X_teste)

precisao_votacao = accuracy_score(y_pred_votacao, y_teste)

print(f"Precisão do Classificador de Votação: {precisao_votacao:.4f}")

Saída de Exemplo:

Precisão do Classificador de Votação: 0.8650

1	Precisão do Classificador de Votação: 0.8650

Explorando Métodos de Conjunto Manual

Enquanto os Classificadores de Votação oferecem uma abordagem direta para o aprendizado de conjunto, os Métodos de Conjunto Manual proporcionam maior flexibilidade ao permitir estratégias personalizadas para combinar as previsões dos modelos. Esta seção descreve uma implementação de conjunto manual através da média das probabilidades previstas pelos classificadores individuais.

Implementação Passo a Passo de Conjunto Manual

1. Prevê Probabilidades com Modelos Individuais

# Prever probabilidades com KNN
p1 = knn.predict_proba(X_teste)

# Prever probabilidades com Regressão Logística
p2 = lr.predict_proba(X_teste)

# Prever probabilidades com KNN

p1 = knn.predict_proba(X_teste)

# Prever probabilidades com Regressão Logística

p2 = lr.predict_proba(X_teste)

2. Fazendo a Média das Probabilidades

# Média das probabilidades previstas
p_media = (p1 + p2) / 2

1 2	# Média das probabilidades previstas p_media = (p1 + p2) / 2

3. Previsão Final Baseada nas Probabilidades Médias

# Converter probabilidades médias para previsões finais
y_pred_manual = np.argmax(p_media, axis=1)

# Avaliar precisão
precisao_manual = accuracy_score(y_pred_manual, y_teste)
print(f"Precisão do Conjunto Manual: {precisao_manual:.4f}")

# Converter probabilidades médias para previsões finais

y_pred_manual = np.argmax(p_media, axis=1)

# Avaliar precisão

precisao_manual = accuracy_score(y_pred_manual, y_teste)

print(f"Precisão do Conjunto Manual: {precisao_manual:.4f}")

Saída de Exemplo:

Precisão do Conjunto Manual: 0.8600

1	Precisão do Conjunto Manual: 0.8600

Implementação Prática: Previsão do Tempo

Para ilustrar a aplicação das técnicas de conjunto, usaremos um conjunto de dados meteorológicos do Kaggle que prevê se vai chover amanhã com base em vários fatores meteorológicos.

Pré-processamento de Dados

O pré-processamento adequado de dados é crucial para construir modelos eficazes de aprendizado de máquina. Isso envolve o tratamento de valores ausentes, codificação de variáveis categóricas, seleção de características relevantes e escalonamento dos dados.

1. Tratamento de Dados Faltantes

Características Numéricas: Imputadas usando a estratégia da média.
Características Categóricas: Imputadas usando a estratégia mais frequente.

2. Codificação de Variáveis Categóricas

Codificação One-Hot: Aplicada a características categóricas com mais de duas categorias únicas.
Codificação Label: Aplicada a características categóricas binárias.

3. Seleção de Características

Usando SelectKBest com a estatística qui-quadrado para selecionar as 5 principais características que têm a relação mais forte com a variável alvo.

4. Escalonamento de Características

Aplicado StandardScaler para normalizar o conjunto de características, garantindo que cada característica contribua igualmente para o desempenho do modelo.

Construção do Modelo

Construímos e avaliamos vários classificadores individuais, incluindo K-Nearest Neighbors, Regressão Logística, Gaussian Naive Bayes, Máquinas de Vetores de Suporte, Árvores de Decisão, Florestas Aleatórias, AdaBoost e XGBoost.

Avaliando Métodos de Conjunto

Implementamos tanto o Classificador de Votação quanto o Conjunto Manual para avaliar seu desempenho em comparação com os modelos individuais.

Conclusão

Técnicas de conjunto, particularmente Classificadores de Votação e Conjuntos Manuais, são ferramentas inestimáveis no arsenal de um profissional de aprendizado de máquina. Ao combinar estrategicamente múltiplos modelos, esses métodos melhoram o desempenho preditivo, reduzem o risco de overfitting e aproveitam as forças de algoritmos diversos. Quer você esteja buscando maior precisão ou modelos mais robustos, dominar métodos de conjunto pode elevar significativamente seus projetos de aprendizado de máquina.

Pontos Principais:

Classificador de Votação: Oferece uma maneira simples e eficaz de combinar múltiplos modelos usando votação majoritária ou média de probabilidades.
Conjunto Manual: Proporciona controle granular sobre como as previsões são combinadas, permitindo estratégias personalizadas que podem superar métodos de conjunto padronizados.
Pré-processamento de Dados: Essencial para garantir que seus modelos sejam treinados com dados limpos e bem estruturados, impactando diretamente a eficácia das técnicas de conjunto.
Avaliação de Modelos: Sempre compare métodos de conjunto com modelos individuais para validar seu valor agregado.

Abrace o aprendizado de conjunto para desbloquear todo o potencial de seus modelos de aprendizado de máquina e impulsionar previsões mais precisas e confiáveis em seus projetos.

Palavras-chave: Técnicas de Conjunto, Classificador de Votação, Conjunto Manual, Aprendizado de Máquina, Python, scikit-learn, Precisão do Modelo, Pré-processamento de Dados, Seleção de Características, Previsão do Tempo, K-Nearest Neighbors, Regressão Logística, Gaussian Naive Bayes, Máquinas de Vetores de Suporte, Árvores de Decisão, Florestas Aleatórias, AdaBoost, XGBoost