S29L06 – CAP 曲线实现

html
在 Python 中实现累积准确率曲线（CAP）：全面指南



在机器学习和数据科学领域，评估分类模型的性能至关重要。在各种评估指标中，累积准确率曲线（Cumulative Accuracy Profile, CAP） 因其对模型性能的直观可视化而脱颖而出，特别是在二元和多类分类问题中。本全面指南深入探讨了 CAP 曲线的概念、其重要性以及使用 Python 的逐步实现。无论您是经验丰富的数据科学家还是初学者，本文都将为您提供有效利用 CAP 曲线的知识。

目录


CAP 曲线简介
理解 CAP 曲线的重要性
CAP 曲线实现的数据准备
处理缺失数据
编码分类变量
特征选择与缩放
构建和评估分类模型
生成 CAP 曲线
使用 CAP 曲线比较多个模型
结论
参考文献



1. CAP 曲线简介

累积准确率曲线（Cumulative Accuracy Profile, CAP） 是用于评估分类模型性能的图形工具。它将模型捕获的累计正实例数与实例总数进行绘图，提供了模型优先识别真实正例能力的直观表示。

CAP 曲线的主要特征：

直观的可视化： 清晰地展示模型性能与随机选择的对比。
模型比较： 便于在同一数据集上比较多个模型。
性能指标： CAP 曲线下的面积（AUC）作为模型评估的指标。



2. 理解 CAP 曲线的重要性

在预测顺序重要的场景中，如客户定位或欺诈检测，CAP 曲线尤其有用。通过可视化模型累计正实例的速度，利益相关者可以评估模型在优先考虑高价值预测方面的有效性。

使用 CAP 曲线的优势：

评估模型性能： 快速衡量模型相对于随机模型的表现。
决策工具： 通过视觉性能辅助选择最优模型。
多功能性： 适用于二元和多类分类问题。



3. CAP 曲线实现的数据准备

适当的数据准备对于准确的模型评估和 CAP 曲线生成至关重要。以下是使用 Python 的 Pandas 和 Scikit-learn 库进行数据预处理的步骤。

逐步数据准备：


导入库：




		
		
			
			
Java
			
			import pandas as pd 
import seaborn as sns
			
				
					
				
					1
2
				
						import pandas as pd 
import seaborn as sns
					
				
			
		



加载数据集：




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



示例输出：




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



分离特征和目标：




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






4. 处理缺失数据

缺失数据可能会扭曲模型性能。在训练之前，必须处理缺失值。

处理数值型缺失值：




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



处理分类变量缺失值：




		
		
			
			
Java
			
			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])
			
				
					
				
					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. 编码分类变量

机器学习模型需要数值输入。对分类变量进行编码对于模型训练至关重要。

独热编码方法：




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



标签编码方法：




		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series) 
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series) 
					
				
			
		



应用编码：




		
		
			
			
Java
			
			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  # Output: (1742, 30)
			
				
					
				
					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 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  # Output: (1742, 30)
					
				
			
		


  

6. 特征选择与缩放

选择相关特征和进行缩放可以确保模型的效率和准确性。

特征选择：




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



特征缩放：




		
		
			
			
Java
			
			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)
			
				
					
				
					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. 构建和评估分类模型

训练多个分类模型以使用 CAP 曲线评估其性能。

训练集与测试集划分：




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



构建模型：

K 最近邻（KNN）：




		
		
			
			
Java
			
			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)  # Output: 0.6475
			
				
					
				
					1
2
3
4
5
6
7
				
						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)  # Output: 0.6475
					
				
			
		



逻辑回归：




		
		
			
			
Java
			
			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)  # Output: ~0.63
			
				
					
				
					1
2
3
4
5
6
				
						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)  # Output: ~0.63
					
				
			
		



高斯朴素贝叶斯：




		
		
			
			
Java
			
			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)  # Output: 0.831
			
				
					
				
					1
2
3
4
5
6
				
						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)  # Output: 0.831
					
				
			
		



支持向量机（SVC）：




		
		
			
			
Java
			
			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)  # Output: 0.8765
			
				
					
				
					1
2
3
4
5
6
				
						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)  # Output: 0.8765
					
				
			
		



决策树分类器：




		
		
			
			
Java
			
			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)  # Output: 0.8175
			
				
					
				
					1
2
3
4
5
6
				
						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)  # Output: 0.8175
					
				
			
		



随机森林分类器：




		
		
			
			
Java
			
			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)  # Output: 0.8725
			
				
					
				
					1
2
3
4
5
6
				
						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)  # Output: 0.8725
					
				
			
		



AdaBoost 分类器：




		
		
			
			
Java
			
			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)  # Output: 0.8725
			
				
					
				
					1
2
3
4
5
6
				
						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)  # Output: 0.8725
					
				
			
		



XGBoost 分类器：




		
		
			
			
Java
			
			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)  # Output: 0.8715
			
				
					
				
					1
2
3
4
5
6
				
						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)  # Output: 0.8715
					
				
			
		






8. 生成 CAP 曲线

绘制 CAP 曲线以可视化模型相对于随机模型的性能。

绘制随机模型：




		
		
			
			
Java
			
			import matplotlib.pyplot as plt

# 测试样本总数
total = len(y_test) 

# 正实例总数
sum_count = np.sum(y_test) 

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

# 绘制随机模型
plt.plot([0, total], [0, sum_count], color='blue', linestyle='--', label='随机模型') 
plt.legend()
plt.xlabel('总观测数', fontsize=16)
plt.ylabel('CAP 值', fontsize=16)
plt.title('累积准确率曲线', fontsize=16)
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						import matplotlib.pyplot as plt
 
# 测试样本总数
total = len(y_test) 
 
# 正实例总数
sum_count = np.sum(y_test) 
 
plt.figure(figsize=(10, 6)) 
 
# 绘制随机模型
plt.plot([0, total], [0, sum_count], color='blue', linestyle='--', label='随机模型') 
plt.legend()
plt.xlabel('总观测数', fontsize=16)
plt.ylabel('CAP 值', fontsize=16)
plt.title('累积准确率曲线', fontsize=16)
plt.show()
					
				
			
		



绘制逻辑回归模型：




		
		
			
			
Java
			
			# 使用逻辑回归进行预测
pred_lr = LRM.predict(X_test)
x_values = np.arange(0, total + 1)

# 排序预测和实际值
sorted_zip = sorted(zip(pred_lr, y_test), reverse=True)

# 生成 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))

# 绘制 CAP 曲线
plt.figure(figsize=(10, 6)) 
plt.plot(x_values, y_values, color='blue', linewidth=3, label='逻辑回归')
plt.plot([0, total], [0, sum_count], linestyle='--', label='随机模型') 

plt.xlabel('总观测数', fontsize=16)
plt.ylabel('CAP 值', fontsize=16)
plt.title('累积准确率曲线', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
			
				
					
				
					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
				
						# 使用逻辑回归进行预测
pred_lr = LRM.predict(X_test)
x_values = np.arange(0, total + 1)
 
# 排序预测和实际值
sorted_zip = sorted(zip(pred_lr, y_test), reverse=True)
 
# 生成 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))
 
# 绘制 CAP 曲线
plt.figure(figsize=(10, 6)) 
plt.plot(x_values, y_values, color='blue', linewidth=3, label='逻辑回归')
plt.plot([0, total], [0, sum_count], linestyle='--', label='随机模型') 
 
plt.xlabel('总观测数', fontsize=16)
plt.ylabel('CAP 值', fontsize=16)
plt.title('累积准确率曲线', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
					
				
			
		






9. 使用 CAP 曲线比较多个模型

通过为多个模型绘制 CAP 曲线，可以直观地评估和比较它们的性能。

定义 CAP 生成函数：




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



绘制多个 CAP 曲线：




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

# 绘制高斯朴素贝叶斯的 CAP
x_gnb, y_gnb = CAP_gen(model_GNB)
plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')

# 绘制 XGBoost 的 CAP
x_xgb, y_xgb = CAP_gen(model_xgb)
plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')

# 绘制 AdaBoost 的 CAP
x_abc, y_abc = CAP_gen(model_ABC)
plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost')

# 绘制随机模型
plt.plot([0, total], [0, sum_count], linestyle='--', label='随机模型') 

plt.xlabel('总观测数', fontsize=16)
plt.ylabel('CAP 值', fontsize=16)
plt.title('累积准确率曲线', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
			
				
					
				
					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)) 
 
# 绘制高斯朴素贝叶斯的 CAP
x_gnb, y_gnb = CAP_gen(model_GNB)
plt.plot(x_gnb, y_gnb, linewidth=3, label='GaussianNB')
 
# 绘制 XGBoost 的 CAP
x_xgb, y_xgb = CAP_gen(model_xgb)
plt.plot(x_xgb, y_xgb, linewidth=3, label='XGBoost')
 
# 绘制 AdaBoost 的 CAP
x_abc, y_abc = CAP_gen(model_ABC)
plt.plot(x_abc, y_abc, linewidth=3, label='AdaBoost')
 
# 绘制随机模型
plt.plot([0, total], [0, sum_count], linestyle='--', label='随机模型') 
 
plt.xlabel('总观测数', fontsize=16)
plt.ylabel('CAP 值', fontsize=16)
plt.title('累积准确率曲线', fontsize=16)
plt.legend(loc='lower right', fontsize=16)
plt.show()
					
				
			
		





从 CAP 曲线可以看出，像XGBoost和SVM (SVC)这样的模型在其各自曲线下的面积较大，展示了相比于随机模型在优先识别真实正例预测方面更高的效率。


10. 结论

累积准确率曲线（CAP） 是评估和比较分类模型的强大工具。其能够相对于随机基线提供清晰的模型性能可视化，使其在决策过程中尤其是在业务关键应用如欺诈检测和客户细分中具有无价的价值。

通过遵循本指南中概述的步骤——从数据预处理和处理缺失值，到编码分类变量和构建稳健模型——您可以在 Python 中有效地实现 CAP 曲线，以深入了解您的模型性能。

采用 CAP 曲线不仅增强了您的模型评估策略，还提升了复杂机器学习模型的可解释性，弥合了数据科学与可操作商业智能之间的差距。


11. 参考文献


Scikit-learn 关于填补缺失值的文档
Scikit-learn 关于特征选择的文档
理解累积准确率曲线（CAP Curves）
XGBoost 文档




免责声明：本文中引用的图像（https://example.com/...）为占位符。请使用与 CAP 曲线相关的实际图像 URL 进行替换。