S29L06 – 캡 곡선 구현

html
Python에서 누적 정확도 프로파일 (CAP) 커브 구현: 종합 가이드



머신러닝과 데이터 과학 분야에서 분류 모델의 성능 평가가 매우 중요합니다. 다양한 평가 지표 중에서 누적 정확도 프로파일 (CAP) 커브는 특히 이진 및 다중 클래스 분류 문제에서 모델 성능을 직관적으로 시각화하는 데 탁월합니다. 이 종합 가이드는 CAP 커브의 개념, 그 중요성, 그리고 Python을 사용한 단계별 구현 방법을 다룹니다. 경험이 풍부한 데이터 과학자이든 초보자이든 이 기사는 CAP 커브를 효과적으로 활용할 수 있는 지식을 제공합니다.

목차


CAP 커브 소개
CAP 커브의 중요성 이해
CAP 커브 구현을 위한 데이터 준비
누락 데이터 처리
범주형 변수 인코딩
특징 선택 및 스케일링
분류 모델 구축 및 평가
CAP 커브 생성
CAP 커브를 사용한 다중 모델 비교
결론
참고 문헌



1. CAP 커브 소개

누적 정확도 프로파일 (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='Random Model') 
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='Random Model') 
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='Logistic Regression')
plt.plot([0, total], [0, sum_count], linestyle='--', label='Random Model') 

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='Logistic Regression')
plt.plot([0, total], [0, sum_count], linestyle='--', label='Random Model') 
 
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='Random Model') 

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='Random Model') 
 
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) 커브 이해하기
XGBoost 문서




면책 조항: 이 기사에서 참조된 이미지 (https://example.com/...)는 자리 표시자입니다. CAP 커브와 관련된 실제 이미지 URL로 교체하십시오.