人才流失预测模型(机器学习）

1. 项目描述

​ 企业的快速发展离不开人才的支撑，可是现在我国的企业的人才流失严重，人才流失问题现在已经成为了关系企业发展的一个重大的问题。这些企业要想在目前激烈的竞争中快速发展，就需要依靠自身的人力资源的来竞争。只有拥有比对方更强，更优秀，更具有创造力的人才，才能在竞争中取得优势。所以如何有效解决我国企业人才流失问题是一个很迫切的任务。人才流失已经成了很多企业正在面临的困境，关键人才的流程对企业的影响尤为明显。​ 无论在IT互联网领域还是传统领域、事业单位，均面临关键人才的流失，作为公司的核心的人力资源部门，我们需要把控员工的基本情况，对员工的情况进行实时监控和预测，人才流失模型从公司的角度和员工自身角度分别入手，阐释了在那些重要维度能够保持流失率的下降，常规的做法比如增强企业文化，提高薪资，提高年终奖等，通过模型给出人力资源部门一定的建议。

2. 技术说明

​ 项目通过公司内部人资资源系统数据，通过数据的基本ETL(数据清洗过滤和汇总)对数据进行基本的预处理，通过python的numpy、pandas、matplotlib和seaborn进行各维度数据分析，经过数据分析得到分类特征较好的特征数据，对数值型数据、类别型数据、有序性数据分别进行处理和分析，使用label encoder和one encoder分别对类别数据进行特征编码，处理组合后的数据特征后形成特征向量，通过Python的Scikit-learn机器学习库的机器学习算法寻找数据之间存在的关系，从而为公司人力资源及决策层提供信息建议及决策建议

3. 需求分析

1 分析各个维度的数据对人才流失的影响

2 通过训练数据建立的模型以及所给的测试数据，构建人才流失模型，最终预测测试数据相应的员工是否已经离职
 （0未离职，1离职）。

4. 数据集描述

数据主要包括影响员工离职的各种因素（工资、出差、工作环境满意度、工作投入度、是否加班、是否升职、工资提升比例等）以及员工是否已经离职的对应记录。数据分为训练数据和测试数据，分别保存在train.csv和test.csv两个文件中。训练数据主要包括1100条记录，31个字段。

* Attrition：员工是否已经离职，1表示已经离职，0表示未离职，这是目标预测值；
* Age：员工年龄
* BusinessTravel：商务差旅频率，Non-Travel表示不出差，Travel_Rarely表示不经常出差，  Travel_Frequently表示经常出差；
* Department：员工所在部门，Sales表示销售部，Research & Development表示研发部，
  Human Resources表示人力资源部；
* DistanceFromHome：公司跟家庭住址的距离，从1到29，1表示最近，29表示最远；
* Education：员工的教育程度，从1到5，5表示教育程度最高；
* EducationField：员工所学习的专业领域，Life Sciences表示生命科学，Medical表示医疗，
  Marketing表示市场营销，Technical Degree表示技术学位，
  Human Resources表示人力资源，Other表示其他；
* EmployeeNumber：员工号码；
* EnvironmentSatisfaction：员工对于工作环境的满意程度，从1到4，1的满意程度最低，4的满意程度最高；
* Gender：员工性别，Male表示男性，Female表示女性；
* JobInvolvement：员工工作投入度，从1到4，1为投入度最低，4为投入度最高；
* JobLevel：职业级别，从1到5，1为最低级别，5为最高级别；
* JobRole：工作角色：Sales Executive是销售主管，Research Scientist是科学研究员，
Laboratory Technician实验室技术员，Manufacturing Director是制造总监，
Healthcare Representative是医疗代表，Manager是经理，
Sales Representative是销售代表，Research Director是研究总监，
Human Resources是人力资源；
* JobSatisfaction：工作满意度，从1到4，1代表满意程度最低，4代表满意程度最高；
* MaritalStatus：员工婚姻状况，Single代表单身，Married代表已婚，Divorced代表离婚；
* MonthlyIncome：员工月收入，范围在1009到19999之间；
* NumCompaniesWorked：员工曾经工作过的公司数；
* Over18：年龄是否超过18岁；
* OverTime：是否加班，Yes表示加班，No表示不加班；
* PercentSalaryHike：工资提高的百分比；
* PerformanceRating：绩效评估；
* RelationshipSatisfaction：关系满意度，从1到4，1表示满意度最低，4表示满意度最高；
* StandardHours：标准工时；
* StockOptionLevel：股票期权水平；
* TotalWorkingYears：总工龄；
* TrainingTimesLastYear：上一年的培训时长，从0到6，0表示没有培训，6表示培训时间最长；
* WorkLifeBalance：工作与生活平衡程度，从1到4，1表示平衡程度最低，4表示平衡程度最高；
* YearsAtCompany：在目前公司工作年数；
* YearsInCurrentRole：在目前工作职责的工作年数
* YearsSinceLastPromotion：距离上次升职时长
* YearsWithCurrManager：跟目前的管理者共事年数；

5. 开发流程详细描述:

5.1 人员组成和分工:

整体流程:王晓通 柯于辉 数据探索分析,特征处理: 张潇予,常春倩 初始模型: 刘冰冰,郑舒文,马毅景 优化模型:柯于辉,刘冰冰,郑舒文,马毅景 toad跑整个流程: 王晓通,计宇东 汇报: 柯于辉

5.1 数据获取(来源于公司内部的人力资源数据，通常没有缺失值的)

5.1.1 git项目描述

每个组一个总分支: group06: 用于最后合并汇报

组内每个人一个分支: group06_keyuhui, 用于自己个人开发.pull拉取group06分支结构

5.1.2 git项目结构:

# 1. 加载数据,shape,info,desc查看基本信息
data = pd.read_csv('../../data/raw/train.csv')

5.2 数据探索性分析

5.2.1 data.shape()结果

5.2.2 data.info()结果: 无空值情况,有object 需要转数值

 5.2.3 data.describe()结果: 暂时看不出异常,需要处理的地方

5.2.4 数据探索性分析结果:

通过以上shape,info,describe 查看结果: 无空值需要处理, 有object类型需要转数值类型,

其他暂时看不出需要处理之处.

5.3 数据预处理

接下来对object类型数据转数值, 通过分析这些object特征列

商务差旅频率,员工所在部门,员工所学习的专业领域,Gender,
工作角色,员工婚姻状况,年龄是否超过18岁,是否加班,

适合采用label encoder,标签编码

5.4 特征处理

5.4.1 对8个object特征进行 label encoder

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
data['BusinessTravel'] = le.fit_transform(data['BusinessTravel'])
data['Department'] = le.fit_transform(data['Department'])
data['EducationField'] = le.fit_transform(data['EducationField'])
data['Gender'] = le.fit_transform(data['Gender'])
data['JobRole'] = le.fit_transform(data['JobRole'])
data['MaritalStatus'] = le.fit_transform(data['MaritalStatus'])
data['Over18'] = le.fit_transform(data['Over18'])
data['OverTime'] = le.fit_transform(data['OverTime'])

data.head()

5.4.2 转换后结果:

5.5 数据集的划分：使用20%部分作为测试集，80%作为训练集

x_train, x_test, y_train, y_test = train_test_split(data.drop('Attrition',axis=1), data['Attrition'], test_size=0.2, random_state=21)

 

5.6 模型训练：逻辑回归、决策树、随机森林等

5.6.1 逻辑回归: baseline 初始模型训练

# 6. baseline 初始模型训练: 逻辑回归
lr = LogisticRegression()
lr.fit(x_train, y_train)
# 7. 初始模型的AUC值
y_pred_lr = lr.predict_proba(x_test)[:,1]
print('初始模型的AUC值:',roc_auc_score(y_test, y_pred_lr))

 

5.6.2 决策树

# 6.2 决策树
from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier()
dt.fit(x_train, y_train)
# 7. 初始模型决策树AUC值
y_pred_dt = dt.predict_proba(x_test)[:,1]
print('初始模型决策树AUC值:',roc_auc_score(y_test, y_pred_dt))

5.6.3 随机森林

# 6.3 随机森林
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier()
rf.fit(x_train, y_train)
# 7. 初始模型决策树AUC值
y_pred_rf = rf.predict_proba(x_test)[:,1]
print('初始模型随机森林AUC值:',roc_auc_score(y_test, y_pred_rf))

 

5.6.4 adaBoost

# 6.4 AdaBoost
from sklearn.ensemble import AdaBoostClassifier
mytree = DecisionTreeClassifier(criterion='entropy', max_depth=1, random_state=0)
myada = AdaBoostClassifier(estimator=mytree, n_estimators=500, learning_rate=0.1, random_state=0)
myada.fit(x_train, y_train)
# 7. 初始模型决策树AUC值
y_pred_myada = myada.predict_proba(x_test)[:,1]
print('初始模型AdaBoostAUC值:',roc_auc_score(y_test, y_pred_myada))

5.6.5 GBDT

# 6.5 DBDT 
from sklearn.ensemble import GradientBoostingClassifier
gbdt = GradientBoostingClassifier()
gbdt.fit(x_train, y_train)
# 7. 初始模型决策树AUC值
y_pred_gbdt = gbdt.predict_proba(x_test)[:,1]
print('初始模型DBDTAUC值:',roc_auc_score(y_test, y_pred_gbdt))

 

5.6.6 xgboost 

5.6.7 lightGBM

# 6.6 lightGBM
from lightgbm import LGBMClassifier
# 创建lgb对象
lgbm =LGBMClassifier(boosting_type = 'gbdt',objective = 'binary',metric = 'auc',
learning_rate = 0.3,n_estimators = 100,max_depth = 3,num_leaves = 20,
max_bin = 45,min_data_in_leaf = 6,bagging_fraction = 0.6,bagging_freq = 0,
feature_fraction = 0.8)
# 使用这个对象训练lgb模型
lgbm.fit(x_train,y_train,eval_set = [(x_train,y_train),(x_test,y_test)],eval_metric = 'auc')
# 7. 初始模型xgb的AUC值
y_pred_lgbm = lgbm.predict_proba(x_test)[:,1]
print('初始模型lgbm的AUC值:',roc_auc_score(y_test, y_pred_lgbm))

 

结果:初始模型lgbm的AUC值: 0.8018461538461539

5.6.8 对比以上几个模型结果:

模型逻辑回归AUC值: 0.7341538461538462
决策树AUC值: 0.6282051282051282
随机森林AUC值: 0.7871794871794872
AdaBoostAUC值: 0.7749743589743588
GBDTAUC值: 0.7928205128205129
xgb的AUC值: 0.7688205128205129
lgbm的AUC值: 0.8018461538461539

从上面挑选AUC值最高的几个模型做进一步优化: 随机森林,GBDT,xgboost,lightGBM

5.6.9 尝试对随机森林模型进行交叉网络搜索优化

# 6.7.1 随机森林 交叉验证网格搜索 进行模型训练和评估
from sklearn.model_selection import GridSearchCV
estimator = RandomForestClassifier()
param = {"n_estimators": [10, 20, 30, 40, 50, 60, 70], "max_depth": [2, 4, 6, 8, 10], "random_state": [9]}
grid_search = GridSearchCV(estimator, param_grid=param, cv=2)
grid_search.fit(x_train, y_train)
accuracy = grid_search.score(x_test, y_test)
print("随机森林网格搜索accuracy:", accuracy)
# 输出: RandomForestClassifier(max_depth=6, n_estimators=10, random_state=9)
# 就可以根据最优超参组合用模型
print(grid_search.best_estimator_)

# 上面得到最佳模型输出: RandomForestClassifier(max_depth=6, n_estimators=10, random_state=9)
# 6.7.2 根据交叉验证网格搜索 得到的超参组合,得到的模型来测试
rf_best = RandomForestClassifier(max_depth=6, n_estimators=10, random_state=9)
rf_best.fit(x_train, y_train)
y_pred_rf_best = rf_best.predict_proba(x_test)[:,1]
print('RandomForest 交叉验证网格搜索的AUC值:',roc_auc_score(y_test, y_pred_rf_best))

结果:RandomForest 交叉验证网格搜索的AUC值: 0.7132307692307693..

效果还更差,,可见是在训练集上更好,但测试集更差,,过拟合了. 不采用

5.7 模型校验：

模型准确率、召回率、精确率、F1值、ROC曲线(横轴：真正率TRP，纵轴：假正率FPR)-----通过曲线和x轴围城的面积衡量分类性能的好坏，曲线面积叫做AUC值---面积大小代表准确率大小---Roc-Auc曲线

5.7.1 使用验证数据集:

# 先随机森林
# 利用数据集test2.csv 来验证3个模型: 随机森林,GBDT,lightGBM
from sklearn.metrics import accuracy_score, precision_score,recall_score,f1_score,roc_auc_score
y_pred_rf = rf.predict_proba(x_val)[:,1]
# 模型准确率, 、ROC曲线
print('模型准确率',rf.score(x_val,y_val))
print('验证集随机森林AUC值:',roc_auc_score(y_val, y_pred_rf))
y_predict=rf.predict(x_val)
# 计算 召回率、精确率、F1值
print("随机森林的精确率:",precision_score(y_val,y_predict))
print("随机森林的召回率:",recall_score(y_val,y_predict))
print("随机森林的f1-score:",f1_score(y_val,y_predict))

# 结果:
模型准确率 0.8714285714285714
验证集随机森林AUC值: 0.808461978273299
随机森林的精确率: 0.75
随机森林的召回率: 0.22641509433962265
随机森林的f1-score: 0.3478260869565218

# 直接报告api输出:
from sklearn.metrics import classification_report
print("随机森林验证报告:",classification_report(y_val,y_predict))
随机森林验证报告:  precision    recall  f1-score   support

           0       0.88      0.99      0.93       297
           1       0.75      0.23      0.35        53

    accuracy                           0.87       350
   macro avg       0.81      0.61      0.64       350
weighted avg       0.86      0.87      0.84       350

# GBDT
y_pred_gdbt = gbdt.predict_proba(x_val)[:,1]
# 模型准确率, 、ROC曲线
print('GBDT模型准确率',gbdt.score(x_val,y_val))
print('验证集GBDT的AUC值:',roc_auc_score(y_val, y_pred_gdbt))
# 结果:
GBDT模型准确率 0.8742857142857143
验证集GBDT的AUC值: 0.7949939648052855
# 报告: 
y_predict=gbdt.predict(x_val)
print("随机森林验证报告:",classification_report(y_val,y_predict))
# 结果 
gbdt验证报告:    precision    recall  f1-score   support

           0       0.89      0.97      0.93       297
           1       0.66      0.36      0.46        53

    accuracy                           0.87       350
   macro avg       0.77      0.66      0.70       350
weighted avg       0.86      0.87      0.86       350

# xgboost
y_pred_xgb = xgb.predict_proba(x_val)[:,1]
# 模型准确率, 、ROC曲线
print('xgb模型准确率',xgb.score(x_val,y_val))
print('验证集xgb的AUC值:',roc_auc_score(y_val, y_pred_xgb))
# 结果:
xgb模型准确率 0.8514285714285714
验证集xgb的AUC值: 0.787497617686297
# 报告
y_predict=xgb.predict(x_val)
print("xgb验证报告:",classification_report(y_val,y_predict))
xgb验证报告:    precision    recall  f1-score   support

           0       0.88      0.96      0.92       297
           1       0.52      0.26      0.35        53

    accuracy                           0.85       350
   macro avg       0.70      0.61      0.63       350
weighted avg       0.82      0.85      0.83       350

# lightGBM
y_pred_lgbm = lgbm.predict_proba(x_val)[:,1]
# 模型准确率, 、ROC曲线
print('lgbm模型准确率',lgbm.score(x_val,y_val))
print('验证集lgbm的AUC值:',roc_auc_score(y_val, y_pred_lgbm))
# 结果:
lgbm模型准确率 0.86
验证集lgbm的AUC值: 0.7875611460517121
# 报告:
y_predict=lgbm.predict(x_val)
print("lgbm验证报告:",classification_report(y_val,y_predict))
lgbm验证报告:     precision    recall  f1-score   support

           0       0.89      0.95      0.92       297
           1       0.56      0.38      0.45        53

    accuracy                           0.86       350
   macro avg       0.73      0.66      0.68       350
weighted avg       0.84      0.86      0.85       350

5.7.2 验证集验证了4个模型:随机森林,GBDT,xgBoost,lightGBM

相差不明显,下一步处理样本.

5.8 处理过采样

5.8.1 用代价敏感class_weight = 'balanced' 调整样本系数重新训练随机森林,

# 训练集: x_train,y_train 1100 条,
# 测试集: x_val,y_val 350条
rf = RandomForestClassifier(class_weight = 'balanced')
rf.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_rf = rf.predict_proba(x_val)[:,1]
print('模型随机森林AUC值:',roc_auc_score(y_val, y_pred_rf))
# 结果:有较大提升(原AUC值:0.808461978273299)
# 输出结果:模型随机森林AUC值: 0.8227558604917096

下一步计算特征重要性,减少不重要特征.再训练验证

5.9 过采样后再次训练

5.9.1 用lightGBM 拟合计算特征重要性

def lgb_test(train_x,train_y,test_x,test_y):
# 创建lgb对象
lgbm =LGBMClassifier(boosting_type = 'gbdt',objective = 'binary',metric = 'auc',
learning_rate = 0.3,n_estimators = 100,max_depth = 3,num_leaves = 20,
max_bin = 45,min_data_in_leaf = 6,bagging_fraction = 0.6,bagging_freq = 0,
feature_fraction = 0.8)
    # 使用这个对象训练lgb模型
lgbm.fit(train_x,train_y,eval_set = [(train_x,train_y),(test_x,test_y)],eval_metric = 'auc')
    # 返回训练好的lgb模型, 返回最佳的分数
return lgbm,lgbm.best_score_['valid_1']['auc']

# 训练集: x_train,y_train 1100 条,
# 测试集: x_val,y_val 350条
model, auc = lgb_test(x_train,y_train,x_val,y_val)
# 计算特征重要性
feature_importance_df = pd.DataFrame({'name':model.booster_.feature_name(),'importance':model.feature_importances_}).set_index('name').sort_values(by='importance',ascending=False) # 为了方便后面结果的拼接, 这里把name 特征的名字作为行索引
feature_importance_df

# 根据特征重要些结果: 先删除7个重要性很低的特征(值<10):
drop_columns=['Education','Gender','Department','JobLevel','Gender','Over18','StandardHours']
x_train= x_train.drop(columns=drop_columns,axis=1)
x_val=x_val.drop(columns=drop_columns,axis=1)
x_train

# 删除7个不重要特征重新训练验证模型
# 随机森林
# 代价敏感跑 逻辑回归
lr = LogisticRegression(C=0.1,class_weight = 'balanced')
lr.fit(x_train, y_train)
# 7. 初始模型决策树AUC值
y_pred_lr = lr.predict_proba(x_val)[:,1]
print('删除不重要特征后,模型逻辑回归AUC值:',roc_auc_score(y_val, y_pred_lr))

# 结果: 模型逻辑回归AUC值: 0.7220634013086844
# 更低,不采用

# lightGBM
# lightGBM
lgbm =LGBMClassifier(boosting_type = 'gbdt',objective = 'binary',metric = 'auc',
learning_rate = 0.3,n_estimators = 100,max_depth = 3,num_leaves = 20,
max_bin = 45,min_data_in_leaf = 6,bagging_fraction = 0.6,bagging_freq = 0,
feature_fraction = 0.8)
lgbm.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_lgbm = lgbm.predict_proba(x_val)[:,1]
print('删除不重要特征后,模型lightGBM的AUC值:',roc_auc_score(y_val, y_pred_lgbm))

# 结果:删除不重要特征后,模型lightGBM的AUC值: 0.8073184676958262
# 相对于前值:0.7875611460517121  有提升

# GBDT
# 训练集: x_train,y_train 1100 条,
# 测试集: x_val,y_val 350条
gbdt = GradientBoostingClassifier()
gbdt.fit(x_train, y_train)
# 7. 初始模型决策树AUC值
y_pred_gbdt = gbdt.predict_proba(x_val)[:,1]
print('删除不重要特征后,模型DBDTAUC值:',roc_auc_score(y_val, y_pred_gbdt))

# 结果:删除不重要特征后,模型DBDTAUC值: 0.8296169239565465
# 对比前值:0.7949939648052855  有较大提升

# GBDT
# 训练集: x_train,y_train 1100 条,
# 测试集: x_val,y_val 350条
gbdt = GradientBoostingClassifier()
gbdt.fit(x_train, y_train)
# 7. 初始模型决策树AUC值
y_pred_gbdt = gbdt.predict_proba(x_val)[:,1]
print('删除不重要特征后,模型DBDTAUC值:',roc_auc_score(y_val, y_pred_gbdt))

# 结果:删除不重要特征后,模型DBDTAUC值: 0.8296169239565465
# 对比前值:0.7949939648052855  有较大提升

# xgBoost
xgb = XGBClassifier(n_estimators=100,eta=0.1,random_state=21)
xgb.fit(x_train, y_train)
# 7. 初始模型xgb的AUC值
y_pred_xgb = xgb.predict_proba(x_val)[:,1]
print('删除不重要特征后,xgb的AUC值:',roc_auc_score(y_val, y_pred_xgb))

# 结果: 删除不重要特征后,xgb的AUC值: 0.8103678292357538
# 对比前值:0.787497617686297 有较大提升

下一步,查看样本平衡性..采用smote 平衡样本再训练验证

5.10 过采样后模型验证

5.10.1 查看样本的平衡情况

# 训练集: x_train,y_train 1100 条,
# 测试集: x_val,y_val 350条
y_train.value_counts()
# 结果:
0,922
1,178
y_val.value_counts()
# 结果:
0,297
1,53

# 可见需要做样本平衡处理.

# 10.3 用lightGBM 预测每个样本概率,倒序排序
#调用函数，进行训练
lgb_model,lgb_auc  = lgb_test(x_train,y_train,x_val,y_val) 
#模型预测
sample = x_train.copy()
sample['bad_ind'] = y_train 
sample['pred'] = lgb_model.predict_proba(x_train)[:,1]  
#对预测结果进行降序排序，这样，排序后的结果中，预测为正样本（坏人）概率越大的越靠前
sample = sample.sort_values(by=['pred'],ascending=True).reset_index()  
sample['rank'] = sample.index.values/len(sample)  
sample

# 再对过滤后数据,smote 少量样本 k近邻插入终结者,,增加少量样本数..达到平衡
# 定义函数去掉预测值与实际值不符的部分
#x：真实的结果
#y：预测的结果
#过滤预测和真实的情况严重不相符的样本
#由于上述表格中，我们是按照pred降序排序，因此越往前，是正样本（坏人）的概率越大，但是实际上是负样本（好人），所以这部分的数据要排除，同理，越往后，是负样本（好人）的概率越大，但是实际上是正样本（坏人），这部分的数据也要排除。
def weight(x, y):
    # 真实标签为0，违约概率为所有样本中最高的10%
    if x == 0 and y < 0.1:
        return 0.1
    # 真实标签为1  违约概率为所有样本中最低的30%
    elif x == 1 and y > 0.7:
        return 0.1
    else:
        return 1

sample['weight'] = sample.apply(lambda row:weight(row['bad_ind'],row['rank']),axis = 1)
sample

#把预测相对比较准的取出来进行过采样
# 结果里: 没有结果为0,weight == 1的情况,所以无需过滤,直接在原数据上smote
# smote_sample = sample[sample.weight == 1]
smote_sample = sample
smote_sample.shape

# 输出结果: (1100, 29)

# 只保留需要训练的特征字段
train_x_smote = smote_sample.drop(columns=['bad_ind','pred','rank','weight'])
train_y_smote = smote_sample['bad_ind']
train_x_smote

# 创建smote过采样函数，进行过采样
from imblearn.over_sampling import SMOTE
def smote(train_x_smote,train_y_smote,K=15,random_state=0):
    smote = SMOTE(k_neighbors=K, n_jobs=1,random_state=random_state)
    #fit_resample，找K个邻居，然后进行过采样
    rex,rey = smote.fit_resample(train_x_smote,train_y_smote)
    return rex,rey
rex,rey =smote(train_x_smote,train_y_smote)

#查看数据smote 前
train_y_smote.value_counts()

# smote前结果:
# 0,922
# 1,178
rey.value_counts()
# smote 后结果
# 0,922
# 1,922

# 再次用smote后的训练数据集训练
# 利用smote后的数据集rex,rey 训练模型
x_train=rex.drop('index',axis=1)
y_train=rey
# 决策树
dt = DecisionTreeClassifier(class_weight = 'balanced')
dt.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_dt = dt.predict_proba(x_val)[:,1]
print('模型决策树AUC值:',roc_auc_score(y_val, y_pred_dt))

# 结果输出: 模型决策树AUC值: 0.5897020519662028 
# 更低,不采用

# 再用smote后的数据集训练
#随机森林
rf = RandomForestClassifier(class_weight = 'balanced')
rf.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_rf = rf.predict_proba(x_val)[:,1]
print('模型随机森林AUC值:',roc_auc_score(y_val, y_pred_rf))

# 结果: 模型随机森林AUC值: 0.7608474683946382
# 更低,不采用

# gbdt
gbdt = GradientBoostingClassifier()
gbdt.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_gbdt = gbdt.predict_proba(x_val)[:,1]
print('模型DBDT的AUC值:',roc_auc_score(y_val, y_pred_gbdt))

# 结果: 模型DBDT的AUC值: 0.7919446032653581
# 更低,不采用

# xgboost
xgb = XGBClassifier(n_estimators=100,eta=0.1,random_state=21)
xgb.fit(x_train, y_train)
# 模型xgb的AUC值
y_pred_xgb = xgb.predict_proba(x_val)[:,1]
print('模型xgb的AUC值:',roc_auc_score(y_val, y_pred_xgb))

# 结果: 模型xgb的AUC值: 0.7953751349977765
# 更低,不采用

# lightGBM
lgbm =LGBMClassifier(boosting_type = 'gbdt',objective = 'binary',metric = 'auc',
learning_rate = 0.3,n_estimators = 100,max_depth = 3,num_leaves = 20,
max_bin = 45,min_data_in_leaf = 6,bagging_fraction = 0.6,bagging_freq = 0,
feature_fraction = 0.8)
lgbm.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_lgbm = lgbm.predict_proba(x_val)[:,1]
print('smote特征后,模型lightGBM的AUC值:',roc_auc_score(y_val, y_pred_lgbm))

# 输出结果: smote特征后,模型lightGBM的AUC值: 0.795629248459437
# 更低, 不采用

5.11 结论: 综上: 最高AUC出现在:

删除不重要特征后,模型DBDT的AUC值: 0.8296169239565465

6. toad 跑整体流程

6.1 先toad把train.csv和test2.csv 合并,select筛选,再2:8分训练集测试集跑GBDT看看效果

# 2. 加载数据
data1 = pd.read_csv('../../data/raw/train.csv')
# object 类型数据转数值类型
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
data1['BusinessTravel'] = le.fit_transform(data1['BusinessTravel'])
data1['Department'] = le.fit_transform(data1['Department'])
data1['EducationField'] = le.fit_transform(data1['EducationField'])
data1['Gender'] = le.fit_transform(data1['Gender'])
data1['JobRole'] = le.fit_transform(data1['JobRole'])
data1['MaritalStatus'] = le.fit_transform(data1['MaritalStatus'])
data1['Over18'] = le.fit_transform(data1['Over18'])
data1['OverTime'] = le.fit_transform(data1['OverTime'])

data1.head()

data2 = pd.read_csv('../../data/raw/test2.csv')
# object 类型数据转数值类型
le = LabelEncoder()
data2['BusinessTravel'] = le.fit_transform(data2['BusinessTravel'])
data2['Department'] = le.fit_transform(data2['Department'])
data2['EducationField'] = le.fit_transform(data2['EducationField'])
data2['Gender'] = le.fit_transform(data2['Gender'])
data2['JobRole'] = le.fit_transform(data2['JobRole'])
data2['MaritalStatus'] = le.fit_transform(data2['MaritalStatus'])
data2['Over18'] = le.fit_transform(data2['Over18'])
data2['OverTime'] = le.fit_transform(data2['OverTime'])

data2.head()

# 合并2份数据试试
data_all=pd.concat([data1,data2])
data_all.head()

# 3. toad特征筛选
# 先来个简单的
ex_lis=['Attrition','EmployeeNumber']   # 排除列: 结果y列,,员工号
dev_slct1, drop_lst= toad.selection.select(data_all, data_all['Attrition'], 
                                                   empty=0.7, iv=0.03, 
                                                   corr=0.7, 
                                                   return_drop=True, 
                                                   exclude=ex_lis) 
print("keep:", dev_slct1.shape[1],  
      "drop empty:", len(drop_lst['empty']), 
      "drop iv:", len(drop_lst['iv']),  
      "drop corr:", len(drop_lst['corr']))

# 直接用筛选后的跑下:
# 5. 数据集的划分: 2:8
x_train, x_test, y_train, y_test = train_test_split(dev_slct1.drop('Attrition',axis=1), dev_slct1['Attrition'], test_size=0.2, random_state=21)
x_train.head()

# 验证集过滤需要的特征列
x_val=data2[dev_slct1.columns] #.drop('Attrition', axis=1),
x_val=x_val.drop('Attrition', axis=1)
y_val = data2['Attrition']
x_val.head()

from sklearn.ensemble import GradientBoostingClassifier

# gbdt
gbdt = GradientBoostingClassifier()
gbdt.fit(x_train, y_train)
# 模型gbdt的AUC值
y_pred_gbdt = gbdt.predict_proba(x_val)[:,1]
print('模型DBDT的AUC值:',roc_auc_score(y_val, y_pred_gbdt))

# 结果输出: 模型DBDT的AUC值: 0.958134807191411
# 有较大提升

# 决策树
dt = DecisionTreeClassifier(class_weight = 'balanced')
dt.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_dt = dt.predict_proba(x_val)[:,1]
print('模型决策树AUC值:',roc_auc_score(y_val, y_pred_dt))

# 结果输出: 模型决策树AUC值: 0.9383457213645894
# 有较大提升

# 随机森林
rf = RandomForestClassifier(class_weight = 'balanced')
rf.fit(x_train, y_train)
# 模型随机森林AUC值
y_pred_rf = rf.predict_proba(x_val)[:,1]
print('模型随机森林AUC值:',roc_auc_score(y_val, y_pred_rf))

# 结果输出: 模型随机森林AUC值: 0.9880566673019503

# xgboost
xgb = XGBClassifier(n_estimators=100,eta=0.1,random_state=21)
xgb.fit(x_train, y_train)
# 模型xgboost的AUC值
y_pred_xgb = xgb.predict_proba(x_val)[:,1]
print('模型xgboost的AUC值:',roc_auc_score(y_val, y_pred_xgb))

# 结果输出: 模型xgboost的AUC值: 0.9758592211422401

# lightGBM
lgbm =LGBMClassifier(boosting_type = 'gbdt',objective = 'binary',metric = 'auc',
learning_rate = 0.3,n_estimators = 100,max_depth = 3,num_leaves = 20,
max_bin = 45,min_data_in_leaf = 6,bagging_fraction = 0.6,bagging_freq = 0,
feature_fraction = 0.8)
lgbm.fit(x_train, y_train)
# 模型lightGBM的AUC值
y_pred_lgbm = lgbm.predict_proba(x_val)[:,1]
print('模型lightGBM的AUC值:',roc_auc_score(y_val, y_pred_lgbm))

# 结果输出: 模型lightGBM的AUC值: 0.961755924020075

6.2 不合并,tain.csv为训练集,test2做测试集

# 不合并2个数据集试试
# 3. toad特征筛选
# data1 为 tain.csv 只做了label encoder
ex_lis=['Attrition','EmployeeNumber']   # 排除列: 结果y列,,员工号
dev_slct2, drop_lst2= toad.selection.select(data1, data1['Attrition'], 
                                                   empty=0.7, iv=0.03, 
                                                   corr=0.7, 
                                                   return_drop=True, 
                                                   exclude=ex_lis) 
print("keep:", dev_slct2.shape[1],  
      "drop empty:", len(drop_lst2['empty']), 
      "drop iv:", len(drop_lst2['iv']),  
      "drop corr:", len(drop_lst2['corr']))

# 训练集
x_train, y_train= dev_slct2.drop('Attrition',axis=1), dev_slct2['Attrition']
x_train.head()

# 测试集
x_val=data2[dev_slct2.columns] 
x_val=x_val.drop('Attrition', axis=1)
y_val = data2['Attrition']
x_val.head()

# gbdt
gbdt = GradientBoostingClassifier()
gbdt.fit(x_train, y_train)
# 模型gbdt的AUC值
y_pred_gbdt = gbdt.predict_proba(x_val)[:,1]
print('模型DBDT的AUC值:',roc_auc_score(y_val, y_pred_gbdt))


# 结果输出: 模型DBDT的AUC值: 0.8524236071405884

# 决策树
dt = DecisionTreeClassifier(class_weight = 'balanced')
dt.fit(x_train, y_train)
# 模型决策树AUC值
y_pred_dt = dt.predict_proba(x_val)[:,1]
print('模型决策树AUC值:',roc_auc_score(y_val, y_pred_dt))

# 结果输出: 模型决策树AUC值: 0.6247061813099549

# 随机森林
rf = RandomForestClassifier(class_weight = 'balanced')
rf.fit(x_train, y_train)
# 模型随机森林AUC值
y_pred_rf = rf.predict_proba(x_val)[:,1]
print('模型随机森林AUC值:',roc_auc_score(y_val, y_pred_rf))

# 结果输出: 模型随机森林AUC值: 0.8129407280350678

# xgboost
xgb = XGBClassifier(n_estimators=100,eta=0.1,random_state=21)
xgb.fit(x_train, y_train)
# 模型xgboost的AUC值
y_pred_xgb = xgb.predict_proba(x_val)[:,1]
print('模型xgboost的AUC值:',roc_auc_score(y_val, y_pred_xgb))

# 结果输出: 模型xgboost的AUC值: 0.8126548503906994

# lightGBM
lgbm =LGBMClassifier(boosting_type = 'gbdt',objective = 'binary',metric = 'auc',
learning_rate = 0.3,n_estimators = 100,max_depth = 3,num_leaves = 20,
max_bin = 45,min_data_in_leaf = 6,bagging_fraction = 0.6,bagging_freq = 0,
feature_fraction = 0.8)
lgbm.fit(x_train, y_train)
# 模型lightGBM的AUC值
y_pred_lgbm = lgbm.predict_proba(x_val)[:,1]
print('模型lightGBM的AUC值:',roc_auc_score(y_val, y_pred_lgbm))

# 结果输出:模型lightGBM的AUC值: 0.8293628104948859

# 综上toad 的select 对tain.csv数据集筛选,训练
# 最高auc: 模型DBDT的AUC值: 0.8524236071405884

原文地址：https://blog.csdn.net/weixin_43147086/article/details/143634007

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！