一文速学-CatBoost算法模型实现贷款违约预测

import catboost
from catboost import CatBoostClassifier, Pool

# 假设我们有一个包含分类特征的数据集
X = [[1, 'a', 0.1], [2, 'b', 0.2], [3, 'a', 0.3], [4, 'b', 0.4]]
y = [0, 1, 0, 1]

# 创建一个 Pool 对象，它会自动识别分类特征
dataset = Pool(data=X, label=y, cat_features=[1])

# 初始化并训练一个 CatBoost 分类器
model = CatBoostClassifier(iterations=100, depth=6, learning_rate=0.1, loss_function='Logloss', verbose=200)
model.fit(dataset)

# 进行预测
preds = model.predict(dataset)

# 输出预测结果
print(preds)

pip installl catboost

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split  
import pandas as pd
train=pd.read_csv("df2.csv")
train=train.iloc[:10000,2:] 
# 划分特征变量与目标变量
X=train.drop(columns='isDefault')
Y=train['isDefault']
# 划分训练及测试集
X_train,X_test,y_train,y_test=train_test_split(X,Y,test_size=0.2,random_state=0)

from catboost.utils import get_roc_curve
# 创建并训练一个CatBoost分类器
model = CatBoostClassifier(iterations=100, depth=6, learning_rate=0.1, loss_function='Logloss')
model.fit(X_train, y_train)
# 假设 df 是你的 Pandas DataFrame
train_data = catboost.Pool(data=X_train, label=y_train)
# 获取特征重要性评估
feature_importance = model.get_feature_importance(data=train_data, type='LossFunctionChange')

# 打印特征重要性得分
for i, score in enumerate(feature_importance):
    print(f'Feature {i}: {score}')

from catboost.utils import get_roc_curve
# 创建并训练一个CatBoost分类器
model = CatBoostClassifier(iterations=100, depth=6, learning_rate=0.1, loss_function='Logloss')
model.fit(X_train, y_train,plot=True)

model = CatBoostClassifier(
    iterations=50,
    random_seed=63,
    learning_rate=0.5,
    custom_loss=['AUC', 'Accuracy']
)
model.fit(
    X_train, y_train,
    eval_set=(X_test, y_test),
    verbose=False,
    plot=True
)

model1 = CatBoostClassifier(
    learning_rate=0.7,
    iterations=100,
    random_seed=0,
    train_dir='learing_rate_0.7'
)

model2 = CatBoostClassifier(
    learning_rate=0.01,
    iterations=100,
    random_seed=0,
    train_dir='learing_rate_0.01'
)
model1.fit(
    X_train, y_train,
    eval_set=(X_test, y_test),
    verbose=False,
    plot=True
)
model2.fit(
    X_train, y_train,
    eval_set=(X_test, y_test),
    verbose=False,
    plot=True
)

from catboost import cv
# 设置参数空间
params = {}
params['loss_function'] = 'Logloss'
params['iterations'] = 80
params['custom_loss'] = 'AUC'
params['random_seed'] = 63
params['learning_rate'] = 0.01
# 直接使用catboost中自带的cv参数。
cv_data = cv(
    params = params,
    pool = Pool(X_train, label=y_train), # 设置Pool类。
    fold_count=5,
    shuffle=True,
    partition_random_seed=0,
    plot=True,   # 设置可视化过程
    stratified=False, 
    verbose=False
)

import numpy as np
best_value = np.min(cv_data['test-Logloss-mean'])
best_iter = np.argmin(cv_data['test-Logloss-mean'])

print('Best validation Logloss score, not stratified: {:.4f}±{:.4f} on step {}'.format(
    best_value,
    cv_data['test-Logloss-std'][best_iter],
    best_iter)
)

model_with_early_stop = CatBoostClassifier(
    eval_metric='AUC',
    iterations=200,
    random_seed=63,
    learning_rate=0.5,
    early_stopping_rounds=20
)
model_with_early_stop.fit(
    X_train, y_train,
    eval_set=(X_test, y_test),
    verbose=False,
    plot=True
)

from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split  
import xgboost as xgb
from sklearn.model_selection import KFold
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

result = []
mean_score = 0
labels=[0,1]
y_pred=model.predict_proba(X_test)[:,1]
def classify_convert(x):
    if x >0.5:
        return 1
    else:
        return 0
list_predict=[]
for i in y_pred:
    list_predict.append(classify_convert(i))
cm= confusion_matrix(y_test.values, list_predict)
sns.heatmap(cm,annot=True ,fmt="d",xticklabels=labels,yticklabels=labels)
print('验证集auc:{}'.format(roc_auc_score(y_test, y_pred)))
mean_score += roc_auc_score(y_test, y_pred)
plt.title('confusion matrix')  # 标题
plt.xlabel('Predict lable')  # x轴
plt.ylabel('True lable')  # y轴
plt.show()
# 模型评估
print('mean 验证集Auc:{}'.format(mean_score))
cat_pre=sum(result)  
from sklearn.metrics import f1_score
print('F1_socre:{}'.format(f1_score(y_test.values, list_predict, average='weighted')))
from sklearn.metrics import recall_score
print('Recall_score:{}'.format(recall_score(y_test.values, list_predict, average='weighted')))
from sklearn.metrics import precision_score
print('Percosopn:{}'.format(precision_score(y_test.values, list_predict, average='weighted')))

# 获取特征名称
feature_names = train_data.get_feature_names()
# 将特征重要性和特征名称结合起来，创建一个字典
feature_importance_dict = dict(zip(feature_names, feature_importance))

# 将特征重要性排序
sorted_feature_importance = sorted(feature_importance_dict.items(), key=lambda x: x[1], reverse=True)

# 提取排序后的特征名称和重要性
sorted_feature_names, sorted_feature_importance = zip(*sorted_feature_importance)

plt.figure(figsize=(10, 6))
plt.barh(sorted_feature_names[:10], sorted_feature_importance[:10])
plt.xlabel('Feature Importance')
plt.title('Top 10 Important Features')
plt.gca().invert_yaxis()  # 反转y轴以显示重要性高的特征在顶部
plt.show()

from catboost import CatBoostClassifier, Pool, cv
from sklearn.model_selection import GridSearchCV
train=pd.read_csv("df2.csv")
train=train.iloc[:40000,2:] 
# 划分特征变量与目标变量
X=train.drop(columns='isDefault')
Y=train['isDefault']
# 划分训练及测试集
X_train,X_test,y_train,y_test=train_test_split(X,Y,test_size=0.2,random_state=0)
train_data = Pool(X_train, label=y_train)

param_grid = {
    'depth': [4, 6, 8],
    'learning_rate': [0.1, 0.05, 0.01,0.001]
}
model = CatBoostClassifier(task_type="GPU")

grid_search = GridSearchCV(estimator=model, param_grid=param_grid, scoring='accuracy', cv=3, verbose=2, n_jobs=-1)

grid_search.fit(X_train,y_train)
best_params = grid_search.best_params_
best_model = CatBoostClassifier(depth=best_params['depth'], learning_rate=best_params['learning_rate'])
best_model.fit(train_data)