金融风控训练营建模与调参学习笔记

 from numpy import loadtxt, where

    
 from pylab import scatter, show, legend, xlabel, ylabel
    
  
    
 #load the dataset
    
 data = loadtxt('/home/HanXiaoyang/data/data1.txt', delimiter=',')
    
  
    
 X = data[:, 0:2]
    
 y = data[:, 2]
    
  
    
 pos = where(y == 1)
    
 neg = where(y == 0)
    
 scatter(X[pos, 0], X[pos, 1], marker='o', c='b')
    
 scatter(X[neg, 0], X[neg, 1], marker='x', c='r')
    
 xlabel('Feature1/Exam 1 score')
    
 ylabel('Feature2/Exam 2 score')
    
 legend(['Fail', 'Pass'])
    
 show()
    
  
    
 ————————————————
    
 版权声明：本文为博主「寒小阳」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    
 原文链接：
    
    
    
    
    AI写代码

 def sigmoid(X):

    
     '''Compute sigmoid function '''
    
     den =1.0+ e **(-1.0* X)
    
     gz =1.0/ den
    
     return gz
    
 def compute_cost(theta,X,y):
    
     '''computes cost given predicted and actual values'''
    
     m = X.shape[0]#number of training examples
    
     theta = reshape(theta,(len(theta),1))
    
     
    
     J =(1./m)*(-transpose(y).dot(log(sigmoid(X.dot(theta))))- transpose(1-y).dot(log(1-sigmoid(X.dot(theta)))))
    
     
    
     grad = transpose((1./m)*transpose(sigmoid(X.dot(theta))- y).dot(X))
    
     #optimize.fmin expects a single value, so cannot return grad
    
     return J[0][0]#,grad
    
 def compute_grad(theta, X, y):
    
     '''compute gradient'''
    
     theta.shape =(1,3)
    
     grad = zeros(3)
    
     h = sigmoid(X.dot(theta.T))
    
     delta = h - y
    
     l = grad.size
    
     for i in range(l):
    
         sumdelta = delta.T.dot(X[:, i])
    
         grad[i]=(1.0/ m)* sumdelta *-1
    
     theta.shape =(3,)
    
     return  grad
    
  
    
  
    
 ————————————————
    
 版权声明：本文为博主「寒小阳」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    
 原文链接：
    
    
    
    
    AI写代码

 def predict(theta, X):

    
     '''Predict label using learned logistic regression parameters'''
    
     m, n = X.shape
    
     p = zeros(shape=(m,1))
    
     h = sigmoid(X.dot(theta.T))
    
     for it in range(0, h.shape[0]):
    
         if h[it]>0.5:
    
             p[it,0]=1
    
         else:
    
             p[it,0]=0
    
     return p
    
 #Compute accuracy on our training set
    
 p = predict(array(theta), it)
    
 print'Train Accuracy: %f'%((y[where(p == y)].size / float(y.size))*100.0)
    
 ————————————————
    
 版权声明：本文为博主「寒小阳」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    
 原文链接：
    
    
    
    
    AI写代码

 from sklearn.model_selection import KFold

    
 # 分离数据集，方便进行交叉验证
    
 X_train = data.loc[data['sample']=='train', :].drop(['id','issueDate','isDefault', 'sample'], axis=1)
    
 X_test = data.loc[data['sample']=='test', :].drop(['id','issueDate','isDefault', 'sample'], axis=1)
    
 y_train = data.loc[data['sample']=='train', 'isDefault']
    
  
    
 # 5折交叉验证
    
 folds = 5
    
 seed = 2020
    
 kf = KFold(n_splits=folds, shuffle=True, random_state=seed)
    
    
    
    
    AI写代码

 """对训练集数据进行划分，分成训练集和验证集，并进行相应的操作"""

    
 from sklearn.model_selection import train_test_split
    
 import lightgbm as lgb
    
 # 数据集划分
    
 X_train_split, X_val, y_train_split, y_val = train_test_split(X_train, y_train, test_size=0.2)
    
 train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
    
 valid_matrix = lgb.Dataset(X_val, label=y_val)
    
  
    
 params = {
    
         'boosting_type': 'gbdt',
    
         'objective': 'binary',
    
         'learning_rate': 0.1,
    
         'metric': 'auc',
    
         'min_child_weight': 1e-3,
    
         'num_leaves': 31,
    
         'max_depth': -1,
    
         'reg_lambda': 0,
    
         'reg_alpha': 0,
    
         'feature_fraction': 1,
    
         'bagging_fraction': 1,
    
         'bagging_freq': 0,
    
         'seed': 2020,
    
         'nthread': 8,
    
         'silent': True,
    
         'verbose': -1,
    
 }
    
  
    
 """使用训练集数据进行模型训练"""
    
 model = lgb.train(params, train_set=train_matrix, valid_sets=valid_matrix, num_boost_round=20000, verbose_eval=1000, early_stopping_rounds=200)
    
    
    
    
    AI写代码

 from sklearn import metrics

    
 from sklearn.metrics import roc_auc_score
    
  
    
 """预测并计算roc的相关指标"""
    
 val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration)
    
 fpr, tpr, threshold = metrics.roc_curve(y_val, val_pre_lgb)
    
 roc_auc = metrics.auc(fpr, tpr)
    
 print('未调参前lightgbm单模型在验证集上的AUC：{}'.format(roc_auc))
    
 """画出roc曲线图"""
    
 plt.figure(figsize=(8, 8))
    
 plt.title('Validation ROC')
    
 plt.plot(fpr, tpr, 'b', label = 'Val AUC = %0.4f' % roc_auc)
    
 plt.ylim(0,1)
    
 plt.xlim(0,1)
    
 plt.legend(loc='best')
    
 plt.title('ROC')
    
 plt.ylabel('True Positive Rate')
    
 plt.xlabel('False Positive Rate')
    
 # 画出对角线
    
 plt.plot([0,1],[0,1],'r--')
    
 plt.show()
    
    
    
    
    AI写代码

 # 调objective

    
 best_obj = dict()
    
 for obj in objective:
    
     model = LGBMRegressor(objective=obj)
    
     """预测并计算roc的相关指标"""
    
     score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    
     best_obj[obj] = score
    
    
    
    
    AI写代码

 # num_leaves

    
 best_leaves = dict()
    
 for leaves in num_leaves:
    
     model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0], num_leaves=leaves)
    
     """预测并计算roc的相关指标"""
    
     score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    
     best_leaves[leaves] = score
    
    
    
    
    AI写代码