Implementación de Curvas de Perfil de Precisión Acumulada (CAP) en Python: Una Guía Integral

En el ámbito del aprendizaje automático y la ciencia de datos, evaluar el rendimiento de los modelos de clasificación es fundamental. Entre varias métricas de evaluación, la Curva de Perfil de Precisión Acumulada (CAP) destaca por su visualización intuitiva del rendimiento del modelo, especialmente en problemas de clasificación binaria y multiclase. Esta guía integral profundiza en el concepto de las Curvas CAP, su importancia y una implementación paso a paso utilizando Python. Ya seas un científico de datos experimentado o un entusiasta en ciernes, este artículo te proporcionará el conocimiento necesario para aprovechar efectivamente las Curvas CAP.

Tabla de Contenidos

Introducción a las Curvas CAP
Comprendiendo la Importancia de las Curvas CAP
Preparación de Datos para la Implementación de la Curva CAP
Manejo de Datos Faltantes
Codificación de Variables Categóricas
Selección y Escalado de Características
Construcción y Evaluación de Modelos de Clasificación
Generación de la Curva CAP
Comparación de Múltiples Modelos Usando Curvas CAP
Conclusión
Referencias

1. Introducción a las Curvas CAP

La Curva de Perfil de Precisión Acumulada (CAP) es una herramienta gráfica utilizada para evaluar el rendimiento de los modelos de clasificación. Plotea el número acumulativo de instancias positivas capturadas por el modelo contra el número total de instancias, ofreciendo una representación visual de la capacidad del modelo para priorizar verdaderos positivos.

Características Clave de las Curvas CAP:

Visualización Intuitiva: Ofrece una representación clara del rendimiento del modelo en comparación con una selección aleatoria.
Comparación de Modelos: Facilita la comparación de múltiples modelos en el mismo conjunto de datos.
Métrica de Rendimiento: El área bajo la Curva CAP (AUC) sirve como una métrica para la evaluación del modelo.

2. Comprendiendo la Importancia de las Curvas CAP

Las Curvas CAP son particularmente beneficiosas en escenarios donde el orden de las predicciones importa, como en la segmentación de clientes o la detección de fraudes. Al visualizar qué tan rápidamente un modelo acumula instancias positivas, los interesados pueden evaluar la efectividad del modelo para priorizar predicciones de alto valor.

Ventajas de Usar Curvas CAP:

Evaluación del Rendimiento del Modelo: Evalúa rápidamente qué tan bien un modelo se desempeña en relación con un modelo aleatorio.
Herramienta de Toma de Decisiones: Ayuda en la selección del modelo óptimo basado en el rendimiento visual.
Versatilidad: Aplicable tanto a problemas de clasificación binaria como multiclase.

3. Preparación de Datos para la Implementación de la Curva CAP

Una preparación adecuada de los datos es crucial para una evaluación precisa del modelo y la generación de la Curva CAP. A continuación, se detalla el proceso de preprocesamiento de datos utilizando las bibliotecas Pandas y Scikit-learn de Python.

Preparación de Datos Paso a Paso:

Importación de Bibliotecas:

Java

import pandas as pd import seaborn as sns

1
2

import pandas as pd
import seaborn as sns

Carga del Conjunto de Datos:

data = pd.read_csv('bangla.csv')
data.tail()

1 2	data = pd.read_csv('bangla.csv') data.tail()

Salida de Muestra:

                                                 file_name  zero_crossing  ...
1737  Tumi Robe Nirobe, Artist - DWIJEN  MUKHOPADHYA...          78516   
1738  TUMI SANDHYAR MEGHMALA  Srikanta Acharya  Rabi...         176887   
...

file_name zero_crossing ...

1737 Tumi Robe Nirobe, Artist - DWIJEN MUKHOPADHYA... 78516

1738 TUMI SANDHYAR MEGHMALA Srikanta Acharya Rabi... 176887

...

Separación de Características y Objetivo:

Java

X = data.iloc[:,:-1] y = data.iloc[:,-1]

1
2

X = data.iloc[:,:-1]
y = data.iloc[:,-1]

4. Manejo de Datos Faltantes

Los datos faltantes pueden distorsionar el rendimiento del modelo. Es esencial abordar los valores faltantes antes del entrenamiento.

Manejo de Valores Faltantes Numéricos:

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])

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])

Manejo de Valores Faltantes Categóricos:

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])

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. Codificación de Variables Categóricas

Los modelos de aprendizaje automático requieren entradas numéricas. La codificación de variables categóricas es fundamental para el entrenamiento del modelo.

Método de Codificación One-Hot:

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)

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 Codificación de Etiquetas:

from sklearn import preprocessing

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

from sklearn import preprocessing

def LabelEncoderMethod(series):

le = preprocessing.LabelEncoder()

le.fit(series)

return le.transform(series)

Aplicando la Codificación:

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 or 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  # Salida: (1742, 30)

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 or 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 # Salida: (1742, 30)

6. Selección y Escalado de Características

Seleccionar características relevantes y escalarlas asegura la eficiencia y precisión del modelo.

Selección de Características:

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  # Salida: (1742, 10)
del x_temp

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 # Salida: (1742, 10)

del x_temp

Escalado de Características:

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)

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. Construcción y Evaluación de Modelos de Clasificación

Se entrenan múltiples modelos de clasificación para evaluar su rendimiento utilizando las Curvas CAP.

División de Entrenamiento y Prueba:

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)

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)

Construcción de Modelos:

K-Vecinos Más Cercanos (KNN):

from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

knnClassifier = 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)  # Salida: 0.6475

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

knnClassifier = 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) # Salida: 0.6475

Regresión Logística:

from sklearn.linear_model import LogisticRegression

LRM = 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)  # Salida: ~0.63

from sklearn.linear_model import LogisticRegression

LRM = 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) # Salida: ~0.63

Naive Bayes Gaussiano:

from sklearn.naive_bayes import GaussianNB

model_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)  # Salida: 0.831

from sklearn.naive_bayes import GaussianNB

model_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) # Salida: 0.831

Máquina de Vector de Soporte (SVC):

from sklearn.svm import SVC

model_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)  # Salida: 0.8765

from sklearn.svm import SVC

model_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) # Salida: 0.8765

Clasificador de Árbol de Decisión:

from sklearn.tree import DecisionTreeClassifier

model_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)  # Salida: 0.8175

from sklearn.tree import DecisionTreeClassifier

model_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) # Salida: 0.8175

Clasificador de Bosque Aleatorio:

from sklearn.ensemble import RandomForestClassifier

model_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)  # Salida: 0.8725

from sklearn.ensemble import RandomForestClassifier

model_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) # Salida: 0.8725

Clasificador AdaBoost:

from sklearn.ensemble import AdaBoostClassifier

model_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)  # Salida: 0.8725

from sklearn.ensemble import AdaBoostClassifier

model_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) # Salida: 0.8725

Clasificador XGBoost:

import xgboost as xgb

model_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)  # Salida: 0.8715

import xgboost as xgb

model_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) # Salida: 0.8715

8. Generación de la Curva CAP

La Curva CAP se plotea para visualizar el rendimiento del modelo en comparación con un modelo aleatorio.

Plotear el Modelo Aleatorio:

import matplotlib.pyplot as plt

# Número total de muestras de prueba
total = len(y_test) 

# Número total de instancias positivas
sum_count = np.sum(y_test) 

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

# Plot del modelo aleatorio
plt.plot([0, total], [0, sum_count], color='blue', linestyle='--', label='Modelo Aleatorio') 
plt.legend()
plt.xlabel('Total de Observaciones', fontsize=16)
plt.ylabel('Valores CAP', fontsize=16)
plt.title('Perfil de Precisión Acumulada', fontsize=16)
plt.show()

import matplotlib.pyplot as plt

# Número total de muestras de prueba

total = len(y_test)

# Número total de instancias positivas

sum_count = np.sum(y_test)

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

# Plot del modelo aleatorio

plt.plot([0, total], [0, sum_count], color='blue', linestyle='--', label='Modelo Aleatorio')

plt.legend()

plt.xlabel('Total de Observaciones', fontsize=16)

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

plt.title('Perfil de Precisión Acumulada', fontsize=16)

plt.show()

Plotear el Modelo de Regresión Logística:

# Predicción usando Regresión Logística
pred_lr = LRM.predict(X_test)
x_values = np.arange(0, total + 1)

# Ordenando predicciones y valores reales
sorted_zip = sorted(zip(pred_lr, y_test), reverse=True)

# Generando 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))

# Plot de la Curva CAP
plt.figure(figsize=(10, 6)) 
plt.plot(x_values, y_values, color='blue', linewidth=3, label='Regresión Logística')
plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatorio') 

plt.xlabel('Total de Observaciones', fontsize=16)
plt.ylabel('Valores CAP', fontsize=16)
plt.title('Perfil de Precisión Acumulada', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()

# Predicción usando Regresión Logística

pred_lr = LRM.predict(X_test)

x_values = np.arange(0, total + 1)

# Ordenando predicciones y valores reales

sorted_zip = sorted(zip(pred_lr, y_test), reverse=True)

# Generando 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))

# Plot de la Curva CAP

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

plt.plot(x_values, y_values, color='blue', linewidth=3, label='Regresión Logística')

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

plt.xlabel('Total de Observaciones', fontsize=16)

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

plt.title('Perfil de Precisión Acumulada', fontsize=16)

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

plt.show()

9. Comparación de Múltiples Modelos Usando Curvas CAP

Al plotear Curvas CAP para múltiples modelos, se puede evaluar y comparar visualmente su rendimiento.

Definiendo una Función de Generación de CAP:

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)

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)

Plotear Múltiples Curvas CAP:

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

# Plot CAP para Gaussian Naive Bayes
x_gnb, y_gnb = CAP_gen(model_GNB)
plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')

# Plot CAP para XGBoost
x_xgb, y_xgb = CAP_gen(model_xgb)
plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')

# Plot CAP para AdaBoost
x_abc, y_abc = CAP_gen(model_ABC)
plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost')

# Plot del modelo aleatorio
plt.plot([0, total], [0, sum_count], linestyle='--', label='Modelo Aleatorio') 

plt.xlabel('Total de Observaciones', fontsize=16)
plt.ylabel('Valores CAP', fontsize=16)
plt.title('Perfil de Precisión Acumulada', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()

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

# Plot CAP para Gaussian Naive Bayes

x_gnb, y_gnb = CAP_gen(model_GNB)

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

# Plot CAP para XGBoost

x_xgb, y_xgb = CAP_gen(model_xgb)

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

# Plot CAP para AdaBoost

x_abc, y_abc = CAP_gen(model_ABC)

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

# Plot del modelo aleatorio

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

plt.xlabel('Total de Observaciones', fontsize=16)

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

plt.title('Perfil de Precisión Acumulada', fontsize=16)

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

plt.show()

De las Curvas CAP, modelos como XGBoost y SVM (SVC) demuestran un rendimiento superior con áreas mayores bajo sus respectivas curvas, lo que indica una mayor eficacia en la priorización de predicciones de verdaderos positivos en comparación con el modelo aleatorio.

10. Conclusión

La Curva de Perfil de Precisión Acumulada (CAP) es una herramienta potente para evaluar y comparar modelos de clasificación. Su capacidad para proporcionar una visualización clara del rendimiento del modelo en relación con una línea base aleatoria la hace invaluable en procesos de toma de decisiones, especialmente en aplicaciones críticas para el negocio como la detección de fraudes y la segmentación de clientes.

Siguiendo los pasos descritos en esta guía—desde el preprocesamiento de datos y el manejo de valores faltantes hasta la codificación de variables categóricas y la construcción de modelos robustos—puedes implementar efectivamente las Curvas CAP en Python para obtener una comprensión más profunda del rendimiento de tus modelos.

Adoptar las Curvas CAP no solo mejora tu estrategia de evaluación de modelos, sino que también eleva la interpretabilidad de modelos de aprendizaje automático complejos, cerrando la brecha entre la ciencia de datos y la inteligencia empresarial accionable.

11. Referencias

Descargo de responsabilidad: Las imágenes referenciadas en este artículo (https://example.com/...) son marcadores de posición. Reemplázalas con URLs de imágenes reales relevantes para las Curvas CAP.