kaggle员工离职预测案例(2)

传送门 🚪

案例背景及数据分析处理过程请看《kaggle员工离职预测案例(1)》
模型评估《kaggle员工离职预测案例(3)》

背景

第一篇文章中说此案例是一个典型的二分类问题，这里我们将采用常见的一些模型如逻辑回归（LogisticRegression），决策树分类（DecisionTreeClassifier），随机森林分类（RandomForestClassifier）。

另本文属于学习笔记，在下面的建模中会对不同的数据集（原始数据、降采数据、过采数据）都进行建模学习预测，以此来对比降采过采的效果。

建模

逻辑回归（LogisticRegression）

#导入常用库
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import KFold,cross_val_score,cross_val_predict
from sklearn.metrics import confusion_matrix, recall_score, classification_report

使用交叉验证的方法寻找最佳参数，将方法函数封装起来，后面不同的模型和数据集可以直接调用，而非常方便。

#导入常用库
def printing_Kfold_scores(x_train_XXX, y_train_XXX):
    fold = KFold(5, shuffle = False)
    
    #定义不同的惩罚力度，数值越大惩罚力度越小，可以查看官网
    c_param_range = [0.01,0.1,1,10,100]
    
    #展示结果用的表格
    result_table = pd.DataFrame(index = range(len(c_param_range),2),columns = ['C_parameter','Mean recall score'])
    result_table['C_parameter'] = c_param_range
    
    #k-fold表示k折的交叉验证，这里会得到两个索引集合：训练集 = indices[0],验证集 = indices[1]
    j = 0
    #循环遍历不同的参数
    for c_param in c_param_range:
        print('-----------------------------')
        print('正则化惩罚力度：', c_param)
        print('-----------------------------')
        print('')
        
        recall_accs = []
        
        #一步步分解来执行交叉验证
        for iteration,indices in enumerate(fold.split(x_train_XXX)):
            #指定算法模型，并且给定参数，也可以尝试一下惩罚参数选择'l2'
            lr = LogisticRegression(C = c_param,penalty = 'l1',solver='liblinear')
            
            #训练模型，注意索引不要给错了，训练的时候一定传入的是训练集，所以X和Y的索引都是0
            lr.fit(x_train_XXX.iloc[indices[0],:], y_train_XXX.iloc[indices[0],:].values.ravel())
            
            #建立好模型后，预测模型结果，这里用的就是验证集，索引为1
            y_pred_XXXsample = lr.predict(x_train_XXX.iloc[indices[1],:].values)
            
            #有了预测结果之后就可以来进行评估了，这里recall_score需要传入预测值和真实值
            recall_acc = recall_score(y_train_XXX.iloc[indices[1],:].values, y_pred_XXXsample)
            
            #一会还要算平均，这里就把每一步的结果保存起来
            recall_accs.append(recall_acc)
            print('Iteration {}: 召回率 = {}'.format(iteration,recall_acc))
            
        #当执行完所有交叉验证后，计算平均结果
        result_table.loc[j,'Mean recall score'] = np.mean(recall_accs)
        j += 1 
        print('')
        print('平均召回率',np.mean(recall_accs))
        print('')
        
    #找到最好的参数，哪一个recall高，自然就是最好的了
    best_c = result_table.loc[result_table['Mean recall score'].astype(float).idxmax()]['C_parameter']
    
    #打印最好的结果
    print('************************************************')
    print('效果最好的模型所选的参数 = ',best_c)
    print('************************************************')
    
    return best_c

#导入常用库
print('降采数据下:')
best_c_undersample = printing_Kfold_scores(X_train_undersample,y_train_undersample)
print('过采数据下:')
best_c_oversample = printing_Kfold_scores(X_train_oversample,y_train_oversample)
print('未进行重采样数据下:')
best_c = printing_Kfold_scores(X_train,y_train)

#导入常用库
降采数据下:
-----------------------------
正则化惩罚力度： 0.01
-----------------------------

Iteration 0: 召回率 = 0.0
Iteration 1: 召回率 = 0.0
Iteration 2: 召回率 = 0.0
Iteration 3: 召回率 = 0.0
Iteration 4: 召回率 = 0.0

平均召回率 0.0

-----------------------------
正则化惩罚力度： 0.1
-----------------------------

Iteration 0: 召回率 = 0.8333333333333334
Iteration 1: 召回率 = 0.4411764705882353
Iteration 2: 召回率 = 0.8
Iteration 3: 召回率 = 0.5151515151515151
Iteration 4: 召回率 = 0.48484848484848486

平均召回率 0.6149019607843137

-----------------------------
正则化惩罚力度： 1
-----------------------------

Iteration 0: 召回率 = 0.8666666666666667
Iteration 1: 召回率 = 0.6764705882352942
Iteration 2: 召回率 = 0.8
Iteration 3: 召回率 = 0.6363636363636364
Iteration 4: 召回率 = 0.696969696969697

平均召回率 0.7352941176470589

-----------------------------
正则化惩罚力度： 10
-----------------------------

Iteration 0: 召回率 = 0.8666666666666667
Iteration 1: 召回率 = 0.7647058823529411
Iteration 2: 召回率 = 0.8333333333333334
Iteration 3: 召回率 = 0.696969696969697
Iteration 4: 召回率 = 0.6666666666666666

平均召回率 0.765668449197861

-----------------------------
正则化惩罚力度： 100
--------