Implementando Curvas de Perfil de Precisão Cumulativa (CAP) em Python: Um Guia Abrangente

No campo de aprendizado de máquina e ciência de dados, avaliar o desempenho de modelos de classificação é fundamental. Entre várias métricas de avaliação, a Curva de Perfil de Precisão Cumulativa (CAP) destaca-se por sua visualização intuitiva do desempenho do modelo, especialmente em problemas de classificação binária e multi-classe. Este guia abrangente explora o conceito de Curvas CAP, sua importância e uma implementação passo a passo usando Python. Seja você um cientista de dados experiente ou um entusiasta iniciante, este artigo o equipará com o conhecimento para aproveitar efetivamente as Curvas CAP.
Índice
- Introdução às Curvas CAP
- Compreendendo a Importância das Curvas CAP
- Preparação de Dados para Implementação da Curva CAP
- Tratamento de Dados Faltantes
- Codificação de Variáveis Categóricas
- Seleção e Escalonamento de Recursos
- Construção e Avaliação de Modelos de Classificação
- Gerando a Curva CAP
- Comparando Múltiplos Modelos Usando Curvas CAP
- Conclusão
- Referências
1. Introdução às Curvas CAP
A Curva de Perfil de Precisão Cumulativa (CAP) é uma ferramenta gráfica usada para avaliar o desempenho de modelos de classificação. Ela plota o número cumulativo de instâncias positivas capturadas pelo modelo em relação ao número total de instâncias, fornecendo uma representação visual da capacidade do modelo de priorizar verdadeiros positivos.
Principais Características das Curvas CAP:
- Visualização Intuitiva: Oferece uma representação clara do desempenho do modelo em comparação com a seleção aleatória.
- Comparação de Modelos: Facilita a comparação de múltiplos modelos no mesmo conjunto de dados.
- Métrica de Desempenho: A área sob a Curva CAP (AUC) serve como uma métrica para avaliação do modelo.
2. Compreendendo a Importância das Curvas CAP
As Curvas CAP são particularmente benéficas em cenários onde a ordem das previsões importa, como na segmentação de clientes ou na detecção de fraudes. Ao visualizar quão rapidamente um modelo acumula instâncias positivas, as partes interessadas podem avaliar a eficácia do modelo em priorizar previsões de alto valor.
Vantagens de Usar Curvas CAP:
- Avaliando o Desempenho do Modelo: Avalia rapidamente quão bem um modelo se comporta em relação a um modelo aleatório.
- Ferramenta de Tomada de Decisão: Auxilia na seleção do modelo ótimo com base no desempenho visual.
- Versatilidade: Aplicável a problemas de classificação binária e multi-classe.
3. Preparação de Dados para Implementação da Curva CAP
A preparação adequada dos dados é crucial para uma avaliação precisa do modelo e para a geração da Curva CAP. A seguir, um passo a passo das etapas de pré-processamento dos dados usando as bibliotecas Pandas e Scikit-learn do Python.
Preparação de Dados Passo a Passo:
- Importando Bibliotecas:
12import pandas as pdimport seaborn as sns
- Carregando o Conjunto de Dados:
12data = pd.read_csv('bangla.csv')data.tail()
Exemplo de Saída:
1234file_name zero_crossing ...1737 Tumi Robe Nirobe, Artist - DWIJEN MUKHOPADHYA... 785161738 TUMI SANDHYAR MEGHMALA Srikanta Acharya Rabi... 176887... - Separando Recursos e Alvo:
12X = data.iloc[:,:-1]y = data.iloc[:,-1]
4. Tratamento de Dados Faltantes
Dados faltantes podem distorcer o desempenho do modelo. É essencial tratar os valores ausentes antes do treinamento.
Tratando Valores Faltantes Numéricos:
1 2 3 4 5 6 7 |
import numpy as np from sklearn.impute import SimpleImputer imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0]) imp_mean.fit(X.iloc[:, numerical_cols]) X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols]) |
Tratando Valores Faltantes Categóricos:
1 2 3 4 |
string_cols = list(np.where((X.dtypes == np.object))[0]) imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent') imp_mode.fit(X.iloc[:, string_cols]) X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols]) |
5. Codificação de Variáveis Categóricas
Modelos de aprendizado de máquina requerem entrada numérica. A codificação de variáveis categóricas é fundamental para o treinamento do modelo.
Método de Codificação One-Hot:
1 2 3 4 5 6 |
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) |
Método de Codificação de Rótulo:
1 2 3 4 5 6 |
from sklearn import preprocessing def LabelEncoderMethod(series): le = preprocessing.LabelEncoder() le.fit(series) return le.transform(series) |
Aplicando a Codificação:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
y = LabelEncoderMethod(y) def EncodingSelection(X, threshold=10): string_cols = list(np.where((X.dtypes == np.object))[0]) one_hot_encoding_indices = [] for col in string_cols: length = len(pd.unique(X[X.columns[col]])) if length == 2 ou length > threshold: X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]]) else: one_hot_encoding_indices.append(col) X = OneHotEncoderMethod(one_hot_encoding_indices, X) return X X = EncodingSelection(X) X.shape # Saída: (1742, 30) |
6. Seleção e Escalonamento de Recursos
Selecionar recursos relevantes e escaloná-los garante a eficiência e a precisão do modelo.
Seleção de Recursos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from sklearn.feature_selection import SelectKBest, chi2 from sklearn import preprocessing kbest = SelectKBest(score_func=chi2, k=10) MMS = preprocessing.MinMaxScaler() K_features = 10 x_temp = MMS.fit_transform(X) x_temp = kbest.fit(x_temp, y) best_features = np.argsort(x_temp.scores_)[-K_features:] features_to_delete = np.argsort(x_temp.scores_)[:-K_features] X = np.delete(X, features_to_delete, axis=1) X.shape # Saída: (1742, 10) del x_temp |
Escalonamento de Recursos:
1 2 3 4 5 6 7 |
from sklearn import preprocessing sc = preprocessing.StandardScaler(with_mean=False) sc.fit(X_train) X_train = sc.transform(X_train) X_test = sc.transform(X_test) |
7. Construção e Avaliação de Modelos de Classificação
Vários modelos de classificação são treinados para avaliar seu desempenho usando Curvas CAP.
Divisão de Treino e Teste:
1 2 3 |
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1) |
Construindo Modelos:
- K-Nearest Neighbors (KNN):
1234567from sklearn.neighbors import KNeighborsClassifierfrom sklearn.metrics import accuracy_scoreknnClassifier = KNeighborsClassifier(n_neighbors=3)knnClassifier.fit(X_train, y_train)y_pred_knn = knnClassifier.predict(X_test)knn_accuracy = accuracy_score(y_pred_knn, y_test) # Saída: 0.6475
- Regressão Logística:
123456from sklearn.linear_model import LogisticRegressionLRM = LogisticRegression(random_state=0, max_iter=200)LRM.fit(X_train, y_train)y_pred_lr = LRM.predict(X_test)lr_accuracy = accuracy_score(y_pred_lr, y_test) # Saída: ~0.63
- Gaussian Naive Bayes:
123456from sklearn.naive_bayes import GaussianNBmodel_GNB = GaussianNB()model_GNB.fit(X_train, y_train)y_pred_gnb = model_GNB.predict(X_test)gnb_accuracy = accuracy_score(y_pred_gnb, y_test) # Saída: 0.831
- Support Vector Machine (SVC):
123456from sklearn.svm import SVCmodel_SVC = SVC()model_SVC.fit(X_train, y_train)y_pred_svc = model_SVC.predict(X_test)svc_accuracy = accuracy_score(y_pred_svc, y_test) # Saída: 0.8765
- Decision Tree Classifier:
123456from sklearn.tree import DecisionTreeClassifiermodel_DTC = DecisionTreeClassifier()model_DTC.fit(X_train, y_train)y_pred_dtc = model_DTC.predict(X_test)dtc_accuracy = accuracy_score(y_pred_dtc, y_test) # Saída: 0.8175
- Random Forest Classifier:
123456from sklearn.ensemble import RandomForestClassifiermodel_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)model_RFC.fit(X_train, y_train)y_pred_rfc = model_RFC.predict(X_test)rfc_accuracy = accuracy_score(y_pred_rfc, y_test) # Saída: 0.8725
- AdaBoost Classifier:
123456from sklearn.ensemble import AdaBoostClassifiermodel_ABC = AdaBoostClassifier()model_ABC.fit(X_train, y_train)y_pred_abc = model_ABC.predict(X_test)abc_accuracy = accuracy_score(y_pred_abc, y_test) # Saída: 0.8725
- Classificador XGBoost:
123456import xgboost as xgbmodel_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')model_xgb.fit(X_train, y_train)y_pred_xgb = model_xgb.predict(X_test)xgb_accuracy = accuracy_score(y_pred_xgb, y_test) # Saída: 0.8715
8. Gerando a Curva CAP
A Curva CAP é plotada para visualizar o desempenho do modelo em relação a um modelo aleatório.
Plotando o Modelo Aleatório:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import matplotlib.pyplot as plt # Número total de amostras de teste total = len(y_test) # Número total de instâncias positivas sum_count = np.sum(y_test) plt.figure(figsize=(10, 6)) # Plotando o modelo aleatório plt.plot([0, total], [0, sum_count], color='blue', linestyle='--', label='Modelo Aleatório') plt.legend() plt.xlabel('Total de Observações', fontsize=16) plt.ylabel('Valores CAP', fontsize=16) plt.title('Perfil de Precisão Cumulativa', fontsize=16) plt.show() |
Plotando o Modelo de Regressão Logística:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
# Predizendo usando Regressão Logística pred_lr = LRM.predict(X_test) x_values = np.arange(0, total + 1) # Ordenando previsões e valores reais sorted_zip = sorted(zip(pred_lr, y_test), reverse=True) # Gerando valores CAP cap = [] for p, o in sorted_zip: if p == o: cap.append(p) else: cap.append(o) y_values = np.append([0], np.cumsum(cap)) # Plotando a Curva CAP plt.figure(figsize=(10, 6)) plt.plot(x_values, y_values, color='blue', linewidth=3, label='Regressão Logística') plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatório') 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() |

9. Comparando Múltiplos Modelos Usando Curvas CAP
Ao plotar Curvas CAP para múltiplos modelos, é possível avaliar e comparar visualmente seu desempenho.
Definindo uma Função de Geração de CAP:
1 2 3 4 5 6 7 8 9 10 11 12 |
def CAP_gen(model, X_test=X_test, y_test=y_test): pred = model.predict(X_test) sorted_zip = sorted(zip(pred, y_test), reverse=True) cap = [] for p, o in sorted_zip: 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 Múltiplas Curvas CAP:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
plt.figure(figsize=(10, 6)) # Plotando CAP para Gaussian Naive Bayes x_gnb, y_gnb = CAP_gen(model_GNB) plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB') # Plotando CAP para XGBoost x_xgb, y_xgb = CAP_gen(model_xgb) plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost') # Plotando CAP para AdaBoost x_abc, y_abc = CAP_gen(model_ABC) plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost') # Plotando o modelo aleatório plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatório') 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() |

Nas Curvas CAP, modelos como o XGBoost e o SVM (SVC) demonstram desempenho superior com áreas maiores sob suas respectivas curvas, indicando maior eficácia na priorização de previsões verdadeiras positivas em comparação com o modelo aleatório.
10. Conclusão
A Curva de Perfil de Precisão Cumulativa (CAP) é uma ferramenta poderosa para avaliar e comparar modelos de classificação. Sua capacidade de fornecer uma visualização clara do desempenho do modelo em relação a uma linha de base aleatória a torna inestimável em processos de tomada de decisão, especialmente em aplicações críticas para negócios, como detecção de fraudes e segmentação de clientes.
Seguindo as etapas delineadas neste guia—desde o pré-processamento de dados e tratamento de valores faltantes até a codificação de variáveis categóricas e a construção de modelos robustos—você pode implementar efetivamente as Curvas CAP em Python para obter insights mais profundos sobre o desempenho de seus modelos.
A adoção das Curvas CAP não só aprimora sua estratégia de avaliação de modelos, mas também eleva a interpretabilidade de modelos complexos de aprendizado de máquina, aproximando a ciência de dados da inteligência de negócios acionável.
11. Referências
- Documentação do Scikit-learn sobre Imputação de Valores Faltantes
- Documentação do Scikit-learn sobre Seleção de Recursos
- Compreendendo as Curvas de Perfil de Precisão Cumulativa (CAP)
- Documentação do XGBoost
Disclaimer: As imagens referenciadas neste artigo (https://example.com/...
) são espaços reservados. Substitua-as por URLs de imagens reais relevantes para as Curvas CAP.