Dominando a Comparação de Modelos com Curvas CAP em Python: Um Guia Abrangente

No campo em rápida evolução da aprendizagem de máquina, selecionar o modelo com melhor desempenho para o seu conjunto de dados é fundamental. Com inúmeros algoritmos disponíveis, determinar qual realmente se destaca pode ser assustador. Apresentamos as Curvas de Perfil de Precisão Cumulativa (CAP)—uma ferramenta poderosa que simplifica o processo de comparar múltiplos modelos. Neste guia abrangente, exploraremos as curvas CAP, demonstraremos como implementá-las em Python e mostraremos sua eficácia em cenários de classificação binária e multiclasse. Seja você um entusiasta de dados ou um praticante experiente, este artigo o equipará com o conhecimento para aprimorar suas técnicas de avaliação de modelos.

Entendendo as Curvas CAP

Curvas de Perfil de Precisão Cumulativa (CAP) são ferramentas gráficas usadas para avaliar o desempenho de modelos de classificação. Elas fornecem uma representação visual da capacidade de um modelo identificar instâncias positivas em relação a um modelo aleatório. Ao plotar o número cumulativo de positivos corretamente previstos contra o número total de observações, as curvas CAP ajudam na avaliação e comparação da eficácia de diferentes modelos.

Por Que Usar Curvas CAP?

Visualização Intuitiva: Oferece uma comparação visual clara entre os modelos.
Métricas de Desempenho: Destaca diferenças na identificação de instâncias positivas.
Versatilidade: Aplicável tanto a problemas de classificação binária quanto multiclasse.

Configurando Seu Ambiente

Antes de mergulhar nas curvas CAP, certifique-se de que seu ambiente Python está configurado com as bibliotecas necessárias. Usaremos bibliotecas como pandas, numpy, scikit-learn, matplotlib e xgboost.

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import (LabelEncoder, OneHotEncoder, StandardScaler,
                                   MinMaxScaler)
from sklearn.impute import SimpleImputer
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score
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

import pandas as pd

import numpy as np

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import (LabelEncoder, OneHotEncoder, StandardScaler,

MinMaxScaler)

from sklearn.impute import SimpleImputer

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.metrics import accuracy_score

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

Pré-processamento de Dados

O pré-processamento de dados é uma etapa crítica nos fluxos de trabalho de aprendizagem de máquina. Ele garante que os dados estejam limpos, bem estruturados e adequados para a modelagem.

Tratamento de Dados Faltantes

Dados faltantes podem distorcer os resultados e reduzir a precisão do modelo. Veja como lidar com valores faltantes numéricos e categóricos:

# Para colunas numéricas
import numpy as np
from sklearn.impute import SimpleImputer

imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imp_mean.fit(X[numerical_cols])
X[numerical_cols] = imp_mean.transform(X[numerical_cols])

# Para colunas categóricas
from sklearn.impute import SimpleImputer

imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
categorical_cols = X.select_dtypes(include=['object']).columns
imp_mode.fit(X[categorical_cols])
X[categorical_cols] = imp_mode.transform(X[categorical_cols])

# Para colunas numéricas

import numpy as np

from sklearn.impute import SimpleImputer

imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

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

imp_mean.fit(X[numerical_cols])

X[numerical_cols] = imp_mean.transform(X[numerical_cols])

# Para colunas categóricas

from sklearn.impute import SimpleImputer

imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

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

imp_mode.fit(X[categorical_cols])

X[categorical_cols] = imp_mode.transform(X[categorical_cols])

Codificação de Variáveis Categóricas

A maioria dos algoritmos de aprendizagem de máquina requer entrada numérica. A codificação converte variáveis categóricas em um formato numérico.

Codificação One-Hot

Adequada para variáveis com mais de duas categorias.

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough')
    return columnTransformer.fit_transform(data)

X = OneHotEncoderMethod(categorical_cols, X)

from sklearn.compose import ColumnTransformer

from sklearn.preprocessing import OneHotEncoder

def OneHotEncoderMethod(indices, data):

columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough')

return columnTransformer.fit_transform(data)

X = OneHotEncoderMethod(categorical_cols, X)

Codificação de Rótulos

Adequada para variáveis categóricas com duas categorias ou variáveis com muitas categorias onde a codificação one-hot pode não ser viável.

from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)

# Aplicar codificação de rótulos à variável alvo
y = LabelEncoderMethod(y)

from sklearn import preprocessing

def LabelEncoderMethod(series):

le = preprocessing.LabelEncoder()

le.fit(series)

return le.transform(series)

# Aplicar codificação de rótulos à variável alvo

y = LabelEncoderMethod(y)

Seleção de Características

A seleção de características ajuda a reduzir o sobreajuste, melhorar a precisão e reduzir o tempo de treinamento.

from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing

# Escalonando as características
scaler = preprocessing.MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Selecionando as 5 melhores características com base no teste qui-quadrado
kbest = SelectKBest(score_func=chi2, k=5)
kbest.fit(X_scaled, y)
best_features = kbest.get_support(indices=True)
X = X[:, best_features]

from sklearn.feature_selection import SelectKBest, chi2

from sklearn import preprocessing

# Escalonando as características

scaler = preprocessing.MinMaxScaler()

X_scaled = scaler.fit_transform(X)

# Selecionando as 5 melhores características com base no teste qui-quadrado

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

kbest.fit(X_scaled, y)

best_features = kbest.get_support(indices=True)

X = X[:, best_features]

Escalonamento de Características

O escalonamento garante que todas as características contribuam igualmente para o treinamento do modelo.

from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)
X = sc.fit_transform(X)

from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)

X = sc.fit_transform(X)

Construindo e Avaliando Modelos

Com os dados pré-processados, é hora de construir vários modelos de classificação e avaliar seu desempenho.

K-Nearest Neighbors (KNN)

from sklearn.neighbors import KNeighborsClassifier

knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)
y_pred_knn = knnClassifier.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn}')

from sklearn.neighbors import KNeighborsClassifier

knnClassifier = KNeighborsClassifier(n_neighbors=3)

knnClassifier.fit(X_train, y_train)

y_pred_knn = knnClassifier.predict(X_test)

accuracy_knn = accuracy_score(y_pred_knn, y_test)

print(f'KNN Accuracy: {accuracy_knn}')

Regressão Logística

from sklearn.linear_model import LogisticRegression

logreg = LogisticRegression(random_state=0, max_iter=200)
logreg.fit(X_train, y_train)
y_pred_logreg = logreg.predict(X_test)
accuracy_logreg = accuracy_score(y_pred_logreg, y_test)
print(f'Regressão Logística Accuracy: {accuracy_logreg}')

from sklearn.linear_model import LogisticRegression

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

logreg.fit(X_train, y_train)

y_pred_logreg = logreg.predict(X_test)

accuracy_logreg = accuracy_score(y_pred_logreg, y_test)

print(f'Regressão Logística Accuracy: {accuracy_logreg}')

Nota: Você pode encontrar um ConvergenceWarning. Para resolver isso, considere aumentar max_iter ou selecionar um solver diferente.

Gaussian Naive Bayes

from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb}')

from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()

gnb.fit(X_train, y_train)

y_pred_gnb = gnb.predict(X_test)

accuracy_gnb = accuracy_score(y_pred_gnb, y_test)

print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb}')

Máquina de Vetores de Suporte (SVM)

from sklearn.svm import SVC

svc = SVC()
svc.fit(X_train, y_train)
y_pred_svc = svc.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc}')

from sklearn.svm import SVC

svc = SVC()

svc.fit(X_train, y_train)

y_pred_svc = svc.predict(X_test)

accuracy_svc = accuracy_score(y_pred_svc, y_test)

print(f'SVM Accuracy: {accuracy_svc}')

Árvore de Decisão

from sklearn.tree import DecisionTreeClassifier

dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)
y_pred_dtc = dtc.predict(X_test)
accuracy_dtc = accuracy_score(y_pred_dtc, y_test)
print(f'Árvore de Decisão Accuracy: {accuracy_dtc}')

from sklearn.tree import DecisionTreeClassifier

dtc = DecisionTreeClassifier()

dtc.fit(X_train, y_train)

y_pred_dtc = dtc.predict(X_test)

accuracy_dtc = accuracy_score(y_pred_dtc, y_test)

print(f'Árvore de Decisão Accuracy: {accuracy_dtc}')

Random Forest

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=500, max_depth=5)
rfc.fit(X_train, y_train)
y_pred_rfc = rfc.predict(X_test)
accuracy_rfc = accuracy_score(y_pred_rfc, y_test)
print(f'Random Forest Accuracy: {accuracy_rfc}')

from sklearn.ensemble import RandomForestClassifier

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

rfc.fit(X_train, y_train)

y_pred_rfc = rfc.predict(X_test)

accuracy_rfc = accuracy_score(y_pred_rfc, y_test)

print(f'Random Forest Accuracy: {accuracy_rfc}')

AdaBoost

from sklearn.ensemble import AdaBoostClassifier

abc = AdaBoostClassifier()
abc.fit(X_train, y_train)
y_pred_abc = abc.predict(X_test)
accuracy_abc = accuracy_score(y_pred_abc, y_test)
print(f'AdaBoost Accuracy: {accuracy_abc}')

from sklearn.ensemble import AdaBoostClassifier

abc = AdaBoostClassifier()

abc.fit(X_train, y_train)

y_pred_abc = abc.predict(X_test)

accuracy_abc = accuracy_score(y_pred_abc, y_test)

print(f'AdaBoost Accuracy: {accuracy_abc}')

XGBoost

import xgboost as xgb

xgb_classifier = xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
xgb_classifier.fit(X_train, y_train)
y_pred_xgb = xgb_classifier.predict(X_test)
accuracy_xgb = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {accuracy_xgb}')

import xgboost as xgb

xgb_classifier = xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')

xgb_classifier.fit(X_train, y_train)

y_pred_xgb = xgb_classifier.predict(X_test)

accuracy_xgb = accuracy_score(y_pred_xgb, y_test)

print(f'XGBoost Accuracy: {accuracy_xgb}')

Nota: O XGBoost pode emitir avisos sobre codificação de rótulos e métricas de avaliação. Ajuste os parâmetros conforme mostrado acima para suprimir os avisos.

Gerando Curvas CAP

As curvas CAP fornecem um meio visual para comparar o desempenho de diferentes modelos. Veja como gerá-las:

Definindo a Função de Geração de CAP

def CAP_gen(model, X_test, y_test):
    pred = model.predict(X_test)
    _ = sorted(zip(pred, y_test), reverse=True)
    _cap = []
    for p, o in _:
        if p == o:
            _cap.append(p)
        else:
            _cap.append(o)
    y_values = np.append([0], np.cumsum(_cap))
    x_values = np.arange(0, len(y_test) + 1)
    return x_values, y_values

def CAP_gen(model, X_test, y_test):

pred = model.predict(X_test)

_ = sorted(zip(pred, y_test), reverse=True)

_cap = []

for p, o in _:

if p == o:

_cap.append(p)

else:

_cap.append(o)

y_values = np.append([0], np.cumsum(_cap))

x_values = np.arange(0, len(y_test) + 1)

return x_values, y_values

Plotando as Curvas CAP

import matplotlib.pyplot as plt

total = len(y_test)
sum_count = np.sum(y_test)

plt.figure(figsize=(10, 6))

# Gerar CAP para GaussianNB
x_gnb, y_gnb = CAP_gen(gnb, X_test, y_test)
plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')

# Gerar CAP para XGBoost
x_xgb, y_xgb = CAP_gen(xgb_classifier, X_test, y_test)
plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')

# Opcional: Adicionar mais modelos
# x_abc, y_abc = CAP_gen(abc, X_test, y_test)
# plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost')

# x_rfc, y_rfc = CAP_gen(rfc, X_test, y_test)
# plt.plot(x_rfc, y_rfc, linewidth=3, label='Random Forest')

# Linha do Modelo Aleatório
plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatório')

# Estética do Gráfico
plt.xlabel('Total de Observações', fontsize=16)
plt.ylabel('Valores CAP', fontsize=16)
plt.title('Perfil de Precisão Cumulativa', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()

import matplotlib.pyplot as plt

total = len(y_test)

sum_count = np.sum(y_test)

plt.figure(figsize=(10, 6))

# Gerar CAP para GaussianNB

x_gnb, y_gnb = CAP_gen(gnb, X_test, y_test)

plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')

# Gerar CAP para XGBoost

x_xgb, y_xgb = CAP_gen(xgb_classifier, X_test, y_test)

plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')

# Opcional: Adicionar mais modelos

# x_abc, y_abc = CAP_gen(abc, X_test, y_test)

# plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost')

# x_rfc, y_rfc = CAP_gen(rfc, X_test, y_test)

# plt.plot(x_rfc, y_rfc, linewidth=3, label='Random Forest')

# Linha do Modelo Aleatório

plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatório')

# Estética do Gráfico

plt.xlabel('Total de Observações', fontsize=16)

plt.ylabel('Valores CAP', fontsize=16)

plt.title('Perfil de Precisão Cumulativa', fontsize=16)

plt.legend(loc='lower right', fontsize=16)

plt.show()

Interpretando as Curvas CAP

Linha Diagonal: Representa o Modelo Aleatório. Um bom modelo deve permanecer acima dessa linha.
Curvas dos Modelos: A curva mais próxima do canto superior esquerdo indica um modelo com melhor desempenho.
Área Sob a Curva (AUC): Uma AUC mais alta significa melhor desempenho.

Classificação Multiclasse com Curvas CAP

Embora as curvas CAP sejam tradicionalmente usadas para classificação binária, elas podem ser adaptadas para problemas multiclasse. Veja como implementar curvas CAP em um ambiente multiclasse usando um conjunto de dados de gêneros musicais Bengali (bangla.csv).

Visão Geral dos Dados

O conjunto de dados bangla.csv compreende 31 características que representam várias características de áudio e uma variável alvo label que indica o gênero musical. Os gêneros incluem categorias como rabindra, adhunik e outros.

Etapas de Pré-processamento

As etapas de pré-processamento permanecem em grande parte semelhantes à classificação binária, com ênfase na codificação da variável alvo multiclasse.

# Codificação de Rótulos para a variável alvo multiclasse
y = LabelEncoderMethod(y)

# Prosseguir com a seleção de codificação, escalonamento de características e divisão como antes

# Codificação de Rótulos para a variável alvo multiclasse

y = LabelEncoderMethod(y)

# Prosseguir com a seleção de codificação, escalonamento de características e divisão como antes

Construindo Modelos Multiclasse

Os mesmos modelos utilizados para classificação binária são aplicáveis aqui. A principal diferença reside na avaliação de seu desempenho em várias classes.

# Exemplo com XGBoost
xgb_classifier = xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
xgb_classifier.fit(X_train, y_train)
y_pred_xgb = xgb_classifier.predict(X_test)
accuracy_xgb = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Multiclasse Accuracy: {accuracy_xgb}')

# Exemplo com XGBoost

xgb_classifier = xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')

xgb_classifier.fit(X_train, y_train)

y_pred_xgb = xgb_classifier.predict(X_test)

accuracy_xgb = accuracy_score(y_pred_xgb, y_test)

print(f'XGBoost Multiclasse Accuracy: {accuracy_xgb}')

Gerando Curvas CAP para Modelos Multiclasse

A função de geração de CAP permanece inalterada. No entanto, a interpretação varia um pouco, pois agora considera múltiplas classes.

# Gerar CAP para GaussianNB
x_gnb, y_gnb = CAP_gen(gnb, X_test, y_test)
plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')

# Gerar CAP para XGBoost
x_xgb, y_xgb = CAP_gen(xgb_classifier, X_test, y_test)
plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')

# Linha do Modelo Aleatório
plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatório')

# Estética do Gráfico
plt.xlabel('Total de Observações', fontsize=16)
plt.ylabel('Valores CAP', fontsize=16)
plt.title('Perfil de Precisão Cumulativa para Classificação Multiclasse', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()

# Gerar CAP para GaussianNB

x_gnb, y_gnb = CAP_gen(gnb, X_test, y_test)

plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')

# Gerar CAP para XGBoost

x_xgb, y_xgb = CAP_gen(xgb_classifier, X_test, y_test)

plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')

# Linha do Modelo Aleatório

plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatório')

# Estética do Gráfico

plt.xlabel('Total de Observações', fontsize=16)

plt.ylabel('Valores CAP', fontsize=16)

plt.title('Perfil de Precisão Cumulativa para Classificação Multiclasse', fontsize=16)

plt.legend(loc='lower right', fontsize=16)

plt.show()

Nota: Em cenários multiclasse, as curvas CAP podem não ser tão diretas de interpretar como na classificação binária. No entanto, elas ainda fornecem insights valiosos sobre o desempenho de um modelo em diferentes classes.

Melhores Práticas e Dicas

Qualidade dos Dados: Garanta que seus dados estejam limpos e bem pré-processados para evitar curvas CAP enganosas.
Diversidade de Modelos: Compare modelos com diferentes algoritmos subjacentes para identificar o melhor desempenho.
Considerações Multiclasse: Tenha cautela ao interpretar curvas CAP em ambientes multiclasse; considere complementar com outras métricas de avaliação, como matrizes de confusão ou pontuações F1.
Evitar Sobreajuste: Utilize técnicas como validação cruzada e regularização para garantir que seus modelos generalizem bem para dados não vistos.
Mantenha-se Atualizado: A aprendizagem de máquina é um campo em constante evolução. Fique atento às últimas ferramentas e melhores práticas para refinar suas estratégias de avaliação de modelos.

Conclusão

Comparar múltiplos modelos de aprendizagem de máquina pode ser desafiador, mas ferramentas como as curvas CAP simplificam o processo ao fornecer insights visuais claros sobre o desempenho dos modelos. Seja lidando com classificação binária ou multiclasse, implementar curvas CAP em Python equipará você com um método robusto para avaliar e selecionar o melhor modelo para seus dados. Lembre-se de priorizar a qualidade dos dados, entender as nuances dos diferentes modelos e interpretar as curvas CAP de forma criteriosa para aproveitar todo o seu potencial em seus empreendimentos de aprendizagem de máquina.

Feliz modelagem!