ML - 贷款用户逾期情况分析3 - 模型调优

最新推荐文章于 2024-04-28 13:05:15 发布
最新推荐文章于 2024-04-28 13:05:15 发布
阅读量1.5k 收藏 11
点赞数 2
分类专栏： Machine Learning 文章标签： 模型调参 XGB调参
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a786150017/article/details/84450807
版权

文章目录

模型调优 (判定贷款用户是否逾期)

给定金融数据，预测贷款用户是否会逾期。
（status是标签：0表示未逾期，1表示逾期。）

Task6（模型调优） - 使用网格搜索对模型进行调优, 并采用五折交叉验证的方式进行模型评估

import pandas as pd

import warnings
warnings.filterwarnings("ignore")

# 数据集预览
data = pd.read_csv('data.csv')
# 去重
data.drop_duplicates(inplace=True)
print(data.shape)
data.head()

导入特征和获取label

import pickle
# 载入特征
with open('feature.pkl', 'rb') as f:
    X = pickle.load(f)

# 观测正负样本是否均衡
y = data.status
y.value_counts()

1. 数据集划分

# 划分训练集测试集
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,random_state=2333)

# 特征归一化
std = StandardScaler()
X_train = std.fit_transform(X_train)
X_test = std.transform(X_test)

2. 模型评估

from sklearn.metrics import accuracy_score, roc_auc_score

def model_metrics(clf, X_train, X_test, y_train, y_test):
    # 预测
    y_train_pred = clf.predict(X_train)
    y_test_pred = clf.predict(X_test)
    
    y_train_proba = clf.predict_proba(X_train)[:,1]
    y_test_proba = clf.predict_proba(X_test)[:,1]
    
    # 准确率
    print('[准确率]', end = ' ')
    print('训练集：', '%.4f'%accuracy_score(y_train, y_train_pred), end = ' ')
    print('测试集：', '%.4f'%accuracy_score(y_test, y_test_pred))
    
    # auc取值：用roc_auc_score或auc
    print('[auc值]', end = ' ')
    print('训练集：', '%.4f'%roc_auc_score(y_train, y_train_proba), end = ' ')
    print('测试集：', '%.4f'%roc_auc_score(y_test, y_test_proba))

导入包

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn import svm
from sklearn.tree import DecisionTreeClassifier
from xgboost.sklearn import XGBClassifier
from lightgbm.sklearn import LGBMClassifier

3. LR模型

lr = LogisticRegression()
param = {'C': [1e-3,0.01,0.1,1,10,100,1e3], 'penalty':['l1', 'l2']}

gsearch = GridSearchCV(lr, param_grid = param,scoring ='roc_auc', cv=5)
gsearch.fit(X_train, y_train)

print('最佳参数：',gsearch.best_params_)
print('训练集的最佳分数：', gsearch.best_score_)
print('测试集的最佳分数：', gsearch.score(X_test, y_test))

输出

最佳参数： {‘C’: 0.1, ‘penalty’: ‘l1’}
训练集的最佳分数： 0.7839975682166337
测试集的最佳分数： 0.7994893464372945

lr = LogisticRegression(C = 0.1, penalty = 'l1')
lr.fit(X_train, y_train)
model_metrics(lr, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.7959 测试集： 0.8073
[auc值] 训练集： 0.8016 测试集： 0.7995

4. SVM模型

调参范围可设为’gamma’:[0.001,0.01,0.1,1,10,100], ‘C’:[0.001,0.01,0.1,1,10,100]}。鉴于时间原因, 下面网格搜索时选用较小区间。

# 1) 线性SVM
svm_linear = svm.SVC(kernel = 'linear', probability=True)
param = {'C':[0.01,0.1,1]}
gsearch = GridSearchCV(svm_linear, param_grid = param,scoring ='roc_auc', cv=5)
gsearch.fit(X_train, y_train)

print('最佳参数：',gsearch.best_params_)
print('训练集的最佳分数：', gsearch.best_score_)
print('测试集的最佳分数：', gsearch.score(X_test, y_test))

输出

最佳参数： {‘C’: 0.01}
训练集的最佳分数： 0.7849963207712166
测试集的最佳分数： 0.810812878176418

svm_linear = svm.SVC(C = 0.01, kernel = 'linear', probability=True)
svm_linear.fit(X_train, y_train)
model_metrics(svm_linear, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.7848 测试集： 0.7912
[auc值] 训练集： 0.8044 测试集： 0.8108

# 2) 多项式SVM
svm_poly = svm.SVC(kernel = 'poly', probability=True)
param = {'C':[0.01,0.1,1]}
gsearch = GridSearchCV(svm_poly, param_grid = param,scoring ='roc_auc', cv=5)
gsearch.fit(X_train, y_train)

print('最佳参数：',gsearch.best_params_)
print('训练集的最佳分数：', gsearch.best_score_)
print('测试集的最佳分数：', gsearch.score(X_test, y_test))

输出

最佳参数： {‘C’: 0.01}
训练集的最佳分数： 0.7359832819347378
测试集的最佳分数： 0.7259879405573931

svm_poly =  svm.SVC(C = 0.01, kernel = 'poly', probability=True)
svm_poly.fit(X_train, y_train)
model_metrics(svm_poly, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.7538 测试集： 0.7547
[auc值] 训练集： 0.8690 测试集： 0.7260

# 3) 高斯SVM
svm_rbf = svm.SVC(probability=True)
param = {'gamma':[0.01,0.1,1,10], 
         'C':[0.01,0.1,1]}
gsearch = GridSearchCV(svm_poly, param_grid = param,scoring ='roc_auc', cv=5)
gsearch.fit(X_train, y_train)

print('最佳参数：',gsearch.best_params_)
print('训练集的最佳分数：', gsearch.best_score_)
print('测试集的最佳分数：', gsearch.score(X_test, y_test))

输出

最佳参数： {‘C’: 0.01, ‘gamma’: 0.01}
训练集的最佳分数： 0.7370458508629731
测试集的最佳分数： 0.7247746108112956

svm_rbf =  svm.SVC(gamma = 0.01, C =0.01 , probability=True)
svm_rbf.fit(X_train, y_train)
model_metrics(svm_rbf, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.7475 测试集： 0.7526
[auc值] 训练集： 0.8614 测试集： 0.7944

# 4) sigmoid - SVM
svm_sigmoid = svm.SVC(kernel = 'sigmoid',probability=True)
param = {'C':[0.01,0.1,1]}
gsearch = GridSearchCV(svm_sigmoid, param_grid = param,scoring ='roc_auc', cv=5)
gsearch.fit(X_train, y_train)

print('最佳参数：',gsearch.best_params_)
print('训练集的最佳分数：', gsearch.best_score_)
print('测试集的最佳分数：', gsearch.score(X_test, y_test))

输出

最佳参数： {‘C’: 0.01}
训练集的最佳分数： 0.7747312761692854
测试集的最佳分数： 0.7803266494690364

svm_sigmoid =  svm.SVC(C = 0.01, kernel = 'sigmoid',probability=True)
svm_sigmoid.fit(X_train, y_train)
model_metrics(svm_sigmoid, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.7475 测试集： 0.7526
[auc值] 训练集： 0.7615 测试集： 0.7803

5. 决策树模型

1）首先对决策树最大深度max_depth和内部节点再划分所需最小样本数min_samples_split进行网格搜索。

param = {'max_depth':range(3,14,2), 'min_samples_split':range(100,801,200)}
gsearch = GridSearchCV(DecisionTreeClassifier(max_depth=8,min_samples_split=300,min_samples_leaf=20, max_features='sqrt' ,random_state =2333),
                       param_grid = param,scoring ='roc_auc', cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘max_depth’: 11, ‘min_samples_split’: 100}, 0.7061428632294259)

2）对内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf一起调参。

param = {'min_samples_split':range(50,1000,100), 'min_samples_leaf':range(60,101,10)}
gsearch = GridSearchCV(DecisionTreeClassifier(max_depth=11,min_samples_split=100,min_samples_leaf=20, max_features='sqrt',random_state =2333),
                       param_grid = param,scoring ='roc_auc', cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘min_samples_leaf’: 80, ‘min_samples_split’: 550}, 0.7118895755089746)

3）再对最大特征数max_features进行网格搜索

param = {'max_features':range(7,20,2)}
gsearch = GridSearchCV(DecisionTreeClassifier(max_depth=11,min_samples_split=550,min_samples_leaf=80, max_features='sqrt',random_state =2333),
                       param_grid = param,scoring ='roc_auc', cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘max_features’: 19}, 0.7050922939313528)

观察最终结果

dt = DecisionTreeClassifier(max_depth=11,min_samples_split=550,min_samples_leaf=80,max_features=19,random_state =2333)
dt.fit(X_train, y_train)
model_metrics(dt, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.7538 测试集： 0.7561
[auc值] 训练集： 0.7155 测试集： 0.6836

6. XGBoost模型

1、max_depth = 5 :这个参数的取值最好在3-10之间。我选的起始值为5，但是你也可以选择其它的值。起始值在4-6之间都是不错的选择。
2、min_child_weight = 1:在这里选了一个比较小的值，因为这是一个极不平衡的分类问题。因此，某些叶子节点下的值会比较小。
3、gamma = 0: 起始值也可以选其它比较小的值，在0.1到0.2之间就可以。这个参数后继也是要调整的。
4、subsample, colsample_bytree = 0.8: 这个是最常见的初始值了。典型值的范围在0.5-0.9之间。

首先看一下默认参数的结果

import warnings
warnings.filterwarnings("ignore")

xgb0 = XGBClassifier()
xgb0.fit(X_train, y_train)

model_metrics(xgb0, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.8530 测试集： 0.8024
[auc值] 训练集： 0.9155 测试集： 0.7932
1）首先从步长(learning rate)和迭代次数(n_estimators)入手。

开始选择一个较小的步长来网格搜索最好的迭代次数。这里，我们将步长初始值设置为0.1, 对于迭代次数进行网格搜索。

param_test = {'n_estimators':range(20,200,20)}
gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.1, n_estimators=140, max_depth=5, 
                                                  min_child_weight=1, gamma=0, subsample=0.8, 
                                                  colsample_bytree=0.8, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

({‘n_estimators’: 20}, 0.7822329511588559)

2） max_depth 和 min_child_weight 参数调优

param_test = {'max_depth':range(3,10,2), 'min_child_weight':range(1,12,2)}

gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.1, n_estimators=20, max_depth=5, 
                                                  min_child_weight=1, gamma=0, subsample=0.8, 
                                                  colsample_bytree=0.8, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘max_depth’: 5, ‘min_child_weight’: 5}, 0.7852805853095239)

可以看出理想的max_depth值为5，理想的min_child_weight值为5。在这个值附近我们可以再进一步调整，来找出理想值。

param_test = {'max_depth':[3,4,5], 'min_child_weight':[3,4,5]}

gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.1, n_estimators=20, max_depth=5, 
                                                  min_child_weight=1, gamma=0, subsample=0.8, 
                                                  colsample_bytree=0.8, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘max_depth’: 5, ‘min_child_weight’: 5}, 0.7852805853095239)

3）gamma参数调优

param_test = {'gamma':[i/10 for i in range(1,6)]}

gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.1, n_estimators=20, max_depth=5, 
                                                  min_child_weight=5, gamma=0, subsample=0.8, 
                                                  colsample_bytree=0.8, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘gamma’: 0.4}, 0.7858965997168706)

4）调整subsample 和 colsample_bytree 参数

param_test = {'subsample':[i/10 for i in range(5,10)], 'colsample_bytree':[i/10 for i in range(5,10)]}

gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.1, n_estimators=20, max_depth=5, 
                                                  min_child_weight=5, gamma=0.4, subsample=0.8, 
                                                  colsample_bytree=0.8, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘colsample_bytree’: 0.9, ‘subsample’: 0.9}, 0.7859006376180202)

从这里可以看出来，subsample理想取值0.9, colsample_bytree理想取值都是0.9。现在，我们以0.05为步长，在这个值附近尝试取值。

param_test = { 'subsample':[i/100 for i in range(85,101,5)], 'colsample_bytree':[i/100 for i in range(85,101,5)]}

gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.1, n_estimators=20, max_depth=5, 
                                                  min_child_weight=5, gamma=0.4, subsample=0.8, 
                                                  colsample_bytree=0.8, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘colsample_bytree’: 0.95, ‘subsample’: 0.9}, 0.7868599289367876)

5）正则化参数调优

#‘reg_lambda’: [0.2, 0.4, 0.6, 0.8, 1]

#  'reg_alpha':[0, 0.001, 0.005, 0.01, 0.05]
param_test = {'reg_alpha':[1e-5, 1e-2, 0.1, 0, 1, 100]}

gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.1, n_estimators=20, max_depth=5, 
                                                  min_child_weight=5, gamma=0.4, subsample=0.95, 
                                                  colsample_bytree=0.9, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘reg_alpha’: 1}, 0.7855783149845719)

6）继续从1）循环调整, 此处省略步骤。
最终选取的模型参数如下：

#XGBClassifier(learning_rate =0.1, n_estimators=60, max_depth=3, min_child_weight=5, 
#              gamma=0.4, subsample=0.5, colsample_bytree=0.9, reg_alpha=1, objective= 'binary:logistic', 
#              nthread=4,scale_pos_weight=1, seed=27)             
# score -  0.7936928753627137

7）回到第1）步，降低学习速率, 调整迭代次数

param_test = {'n_estimators':range(20,200,20)}

gsearch = GridSearchCV(estimator = XGBClassifier(learning_rate =0.01, n_estimators=60, max_depth=3, 
                                                  min_child_weight=5, gamma=0.4, subsample=0.5, 
                                                  colsample_bytree=0.9, reg_alpha=1, objective= 'binary:logistic', 
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

输出：({‘n_estimators’: 180}, 0.7842467214840007)

与1）结果相比, 较好。所以, 选用此处学习速率较小时的结果。继续从1）循环调整, 此处不再调整。

观察最终结果

xgb = XGBClassifier(learning_rate =0.01, n_estimators=180, max_depth=3, min_child_weight=5, 
                    gamma=0.4, subsample=0.5, colsample_bytree=0.9, reg_alpha=1, 
                    objective= 'binary:logistic', nthread=4,scale_pos_weight=1, seed=27)
xgb.fit(X_train, y_train)
model_metrics(xgb, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.8028 测试集： 0.7940
[auc值] 训练集： 0.8257 测试集： 0.7953

7. LightGBM模型

类似XGB， 先调整boosting框架参数, 再调整个体学习器参数。
略

调整过程如下 - 可以划分更详细点

param_test = {'n_estimators':range(20,200,20)}
# param_test = {'max_depth':range(3,10,2), 'min_child_weight':range(1,12,2)}
# param_test = {'gamma':[i/10 for i in range(1,6)]}
# param_test = {'subsample':[i/10 for i in range(5,10)], 'colsample_bytree':[i/10 for i in range(5,10)]}
# param_test = {'reg_alpha':[1e-5, 1e-2, 0.1, 0, 1, 100]}
gsearch = GridSearchCV(estimator = LGBMClassifier(learning_rate =0.1, n_estimators=60, max_depth=3, 
                                                  min_child_weight=11, gamma=0.1, subsample=0.5, 
                                                  colsample_bytree=0.8, reg_alpha = 1e-5,
                                                  nthread=4,scale_pos_weight=1, seed=27), 
                        param_grid = param_test, scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch.fit(X_train, y_train)
# gsearch.grid_scores_, 
gsearch.best_params_, gsearch.best_score_

最终粗调结果如下

lgb = LGBMClassifier(learning_rate =0.1, n_estimators=60, max_depth=3, min_child_weight=11, 
                    gamma=0.1, subsample=0.5, colsample_bytree=0.8, reg_alpha=1e-5, 
                    nthread=4,scale_pos_weight=1, seed=27)
lgb.fit(X_train, y_train)
model_metrics(lgb, X_train, X_test, y_train, y_test)

输出

[准确率] 训练集： 0.8242 测试集： 0.8066
[auc值] 训练集： 0.8715 测试集： 0.7970

结果对比

模型参数准确率auc值
LRLogisticRegression(C = 0.1, penalty = ‘l1’)训练集：0.7959 测试集：0.8073训练集：0.8016 测试集：0.7995
svm_linearsvm.SVC(C = 0.01, kernel = ‘linear’, probability=True)训练集：0.7848 测试集：0.7912训练集：0.8044 测试集：0.8108
svm_polysvm.SVC(C = 0.01, kernel = ‘poly’, probability=True)训练集：0.7538 测试集：0.7547训练集：0.8690 测试集：0.7260
svm_rbfsvm.SVC(gamma = 0.01, C =0.01 , probability=True)训练集 0.7475 测试集：0.7526训练集：0.8614 测试集：0.7944
svm_sigmoidsvm.SVC(C = 0.01, kernel = ‘sigmoid’,probability=True)训练集：0.7475 测试集：0.7526训练集：0.7615 测试集：0.7803
决策树DecisionTreeClassifier(max_depth=11,min_samples_split=550, min_samples_leaf=80,max_features=19)训练集：0.7538 测试集：0.7561训练集：0.7155 测试集：0.6836
XGBoostXGBClassifier(learning_rate =0.01, n_estimators=180, max_depth=3,min_child_weight=5,gamma=0.4, subsample=0.5,colsample_bytree=0.9,reg_alpha=1,objective= ‘binary:logistic’,nthread=4,scale_pos_weight=1, seed=27)训练集：0.8028 测试集：0.7940训练集： 0.8257 测试集：0.7953
LightGBMLGBMClassifier(learning_rate=0.1,n_estimators=60, max_depth=3,min_child_weight=11,gamma=0.1, subsample=0.5, colsample_bytree=0.8,reg_alpha=1e-5, nthread=4, scale_pos_weight=1, seed=27)训练集：0.8242 测试集： 0.8066训练集：0.8715 测试集：0.7970

遇到的问题

XGB调参完还没有默认参数好, 一方面原因是因为没细调，另外是有5折时对score取平均的原因吗？

Reference

XGB调参

XGBoost和LightGBM的参数以及调参

More

代码参见Github: https://github.com/libihan/Exercise-ML

一文速学-XGBoost模型算法原理以及实现+贷款违约预测模型Python项目实战
master_hunter的博客
04-03 9279
集成模型Boosting补完计划第三期了，之前我们已经详细描述了AdaBoost算法模型和GBDT原理以及实践。通过这两类算法就可以明白Boosting算法的核心思想以及基本的运行计算框架，余下几种Boosting算法都是在前者的算法之上改良得到，尤其是以GBDT算法为基础改进衍生出的三种Boosting算法：XGBoost、LightGBM、CatBoost。大家应该都对XGBoost算法模型熟悉但是对GBDT模型一无所知，看过之前GBDT的读者应该对GBDT模型有了一个很清楚的认知，对于理解XGBoos
B.数据挖掘机器学习[六]---项目实战金融风控之贷款违约预测
丨汀、的博客
04-23 4027
相关文章： 特征工程详解及实战项目【参考】 数据挖掘---汽车车交易价格预测[一](测评指标；EDA) 数据挖掘机器学习---汽车交易价格预测详细版本[二]｛EDA-数据探索性分析｝ 数据挖掘机器学习---汽车交易价格预测详细版本[三]｛特征工程、交叉检验、绘制学习率曲线与验证曲线｝ 数据挖掘机器学习---汽车交易价格预测详细版本[四]｛嵌入式特征选择（XGBoots,LightGBM），模型调参（贪心、网格、贝叶斯调参）｝ 数据挖掘机器学习---汽车交易价格预测详细版本[五]｛模型融合(Sta
ML实操 - 贷款用户逾期情况分析
l75326747的博客
11-19 3096
目录 任务描述 实现过程 基本思路 1. 数据集预览 2. 数据预处理 3. 特征工程 4. 模型选择 4.1 数据及划分及数据归一化 4.2 LR 4.3 SVM 4.4 决策树 4.5 Xgboost 4.6 LightGBM 5. 模型调参 6. 性能评估 7. 模型融合 遇到的问题 参考 More 任务描述 给定金融数据，预测贷款用户是否会逾期。（...
ML实操 - 贷款用户逾期情况分析-特征工程
l75326747的博客
11-21 2002
目录 任务描述 特征工程 1. 删除无用变量 2. 特征类型划分 数值型特征 字符型特征 日期/时间型特征 特征合并 3. 特征衍生 4. 特征筛选 性能评估 参考 More 任务描述 给定金融数据，预测贷款用户是否会逾期。（status是标签：0表示未逾期，1表示逾期。） Misson1 - 构建逻辑回归模型进行预测Misson2 - 构建SVM和决策树模型进行预...
ML - 贷款用户逾期情况分析2 - 特征工程1（数据预处理）
libh的博客
11-22 1107
文章目录数据预处理 (判定贷款用户是否逾期)1. 删除无用特征1.1 属性值单一的特征1.2 观测特征取值以及label意义, 是否和预测无关2. 数据处理 - 数值型2.1 缺失值处理2.1.1 中位数填充2.1.2 其他填充缺失值的方法（待补充）2.2 归一化3. 数据处理 - 非数值型3.1 类别特征 - 缺失值处理3.1.1 单独填充为一个类别3.1.2 众数填充3.2 类别特征 - 编码...
一周算法实践---金融贷款逾期模型
weixin_43599067的博客
12-19 781
金融贷款逾期模型 1.读取数据 import pandas as pd data_all = pd.read_csv('../data/data_all.csv')` 2.划分数据集 from sklearn.model_selection import train_test_split x = data_all.drop(['status'], axis=1) y = data_all['st...
金融贷款逾期的模型构建6——特征选择
盛夏光年
01-05 1846
文章目录一、原理 数据传送门（data.csv）：https://pan.baidu.com/s/1G1b2QJjYkkk7LDfGorbj5Q 目标：数据集是金融数据（非脱敏），要预测贷款用户是否会逾期。表格中 “status” 是结果标签：0表示未逾期，1表示逾期。 任务：分别用IV值和随机森林进行特征选择。然后分别构建模型（逻辑回归、SVM、决策树、随机森林、GBDT、XGBoost和Lig...
一文速学-XGBoost模型算法原理以及实现+Python项目实战_xgboost金融领域模型实战
最新发布
2401_84166376的博客
04-28 1149
集成模型Boosting补完计划第三期了，之前我们已经详细描述了AdaBoost算法模型和GBDT原理以及实践。通过这两类算法就可以明白Boosting算法的核心思想以及基本的运行计算框架，余下几种Boosting算法都是在前者的算法之上改良得到，尤其是以GBDT算法为基础改进衍生出的三种Boosting算法：XGBoost、LightGBM、CatBoost。
客户贷款逾期预测[2]-svm和决策树模型
truffle528的博客
11-17 2681
任务         本次以信用贷款数据作为练习数据，目的是学会使用常用的机器学习模型，用它们预测贷款客户是否会逾期，给到的数据已经包含了标签，列名是status，有0和1两种值，0表示未逾期，1表示逾期，所以这是一个二分类的问题。 数据处理         在拿到数据之后，首先我们需要探索数据的构成和分布情况以及缺失情况。对于缺失值处理常用众数或者中位数、平均数填补。为了处理方便，一开始可...
小贷企业的逾期率分析
06-19
逾期率分析，主要通过拆分离职和在职员工对比分析，找到小贷企业降低逾期率的方法。
基于RFM模型对借贷App用户分层分析案例
12-21
一、目的 1、根据还款未复贷老户的借贷数据，对老户进行群体分类； 2、对不同的客户群体进行特征分析，以便于定向营销。 二、分析过程 1、分析思路 数据包含了2018年4月13日至2020年4月9日期间的客户数据，共有22014条记录。在RFM模型的基础上，增加了注册使用App天数这一指标用于客户分群与价值分析，得到本次的LRFM模型，变量解释如下： L：注册使用APP天数。客户注册日期至观测结束日期的间隔。 R：距今还款未复贷天数。客户最近的成功还款日期至观测结束日期的间隔。 F：借款成功次数。观测时间内客户借款成功次数。 M：借款成功总金额。观测时间内客户借款成功总金额。 2、数据提取及处理
支持向量机模型训练与调参
aweizhenlihai的博客
02-16 3332
数据要求 输入的数据为csv格式，可输出混淆矩阵，可将训练好的模型给保存 训练代码 import sklearn.utils from sklearn.svm import SVC import pandas as pd from sklearn.utils.multiclass import unique_labels from sklearn.metrics import confusion_matrix import matplotlib.pyplot as plt import numpy
MyBatis 映射使用方式以及参数传递源码分析
ZHTTTCZY的博客
10-24 209
MyBatis 映射文件 select 1)Mapper接口方法 public Employee getEmployeeById(Integer id ); 2)Mapper映射文件 <select id="getEmployeeById" resultType="com.atguigu.mybatis.beans.Employee" databaseId="mysql"> select * from tbl_employee where id
机器学习算法——SVM支持向量机（基于sklearn代码实现）
weixin_45709671的博客
08-28 2142
SVM在解决分类问题具有良好的效果，出名的软件包有libsvm(支持多种核函数),liblinear。 此外python机器学习库scikit-learn也有svm相关算法sklearn.svm.SVC和sklearn.svm.LinearSVC 分别由libsvm和liblinear发展而来。 使用SVM的一般步骤为： 读取数据，将原始数据转化为SVM算法软件或包所能识别的数据格式； 将数据标准化；(防止样本中不同特征数值大小相差较大影响分类器性能) 选择核函数，在不清楚何种核函数最佳时，推荐尝试RBF
sklearn.svm包中的SVC(kernel=”linear“)和LinearSVC的区别
qq_23069955的博客
07-08 4646
链接 1、LinearSVC使用的是平方hinge loss，SVC使用的是绝对值hinge loss （我们知道，绝对值hinge loss是非凸的，因而你不能用GD去优化，而平方hinge loss可以） 2、LinearSVC使用的是One-vs-All（也成One-vs-Rest）的优化方法，而SVC使用的是One-vs-One （其实我也不明白，如果有人明白恳请指教。。。） 3...
sklearn.svm.SVC 参数说明
热门推荐
学习、思考、总结
08-27 11万+
经常用到sklearn中的SVC函数，这里把文档中的参数翻译了一些，以备不时之需。 本身这个函数也是基于libsvm实现的，所以在参数设置上有很多相似的地方。（PS: libsvm中的二次规划问题的解决算法是SMO）。 sklearn.svm.SVC(C=1.0, kernel='rbf', degree=3, gamma='auto', coef0=0.0, shrinking=True
【python】【SVM method】sklearn.svm包中的SVC(kernel='linear')和LinearSVC的区别
一苇以航丶的博客
08-06 6443
参考文章：https://www.cnblogs.com/zealousness/p/7757603.html
手把手实操系列|贷中逾期风险预测模型开发流程(上)
weixin_45545159的博客
04-24 3725
序言： 随着新客的获客成本越来越高，贷中客户的管理越来越受到放贷机构的重视，其中包括用户流失预测，营销响应预测，逾期风险预测，额度利率管理等。 B卡，又称为行为评为卡，它的作用对象是老客，根据其在账户使用期间所产生的各种行为，来预测未来风险或表现的一种评分模型。本文以小额信贷分期产品为例，介绍B卡中逾期风险预测模型(下面以B卡代称)的开发流程。 本次整体的内容框架如下，我们更会在知识星球上为大家提供本次内容所涉及的实操数据与代码，带领大家领略整个逾期风险预测模型（B卡）内容，整体目录如下： PART 1.B
解读:信贷业务风控逾期指标及风控模型评估指标
寸草心的博客
06-03 1万+
<解读>信贷业务风控逾期指标及风控模型评估指标 一、互联网金融中需要关注的风控逾期指标 1.逾期天数 DPD (Days Past Due) 自应还日次日起到实还日期间的日期数 举例：DPDN+表示逾期天数 >=N天，如DPD30+表逾期天数 >=30天的合同 2.逾期期数 自应还日次日起到实还日期间的日期数 举例： 正常资产用C表示 Mn表示逾期N期:M1逾期一期,M2逾...
SCMA-ML-master项目代码分析与实践
在SCMA-ML-master项目中，机器学习技术很可能被用于优化SCMA系统的性能，例如通过分析用户数据来预测最佳的资源分配方案，或者通过学习通信模式来提高数据传输的准确性。 知识点三：SCMA与ML结合的应用场景 SCMA与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值