科大讯飞“电信客户流失预测挑战赛”baseline复现笔记_机器学习电信预测办理宽带比赛

在复现此竞赛baseline之前，我通过相关资料的学习，粗略了解了集成学习算法框架，给代码加了很详细的注释。下面是复现本次算法所用的学习资料，供零基础同学参考：

网课：清华大学袁博老师“数据挖掘”课程的集成学习部分，上篇博客有发布笔记。

           B站集成学习：XGBoost, lightGBM_哔哩哔哩_bilibili

书籍：周志华老师“机器学习”第1，2，8章

博客：https://blog.csdn.net/qq_41905413/article/details/125284656，好多代码是通过此文了解的

赛事链接：https://challenge.xfyun.cn/topic/info?type=telecom-customer&ch=ds22-dw-zs01

一、赛事背景

随着市场饱和度的上升，电信运营商的竞争也越来越激烈，电信运营商亟待解决减少用户流失，延长用户生命周期的问题。对于客户流失率而言，每增加5%，利润就可能随之降低25%-85%。因此，如何减少电信用户流失的分析与预测至关重要。

鉴于此，运营商会经常设有客户服务部门，该部门的职能主要是做好客户流失分析，赢回高概率流失的客户，降低客户流失率。某电信机构的客户存在大量流失情况，导致该机构的用户量急速下降。面对如此头疼的问题，该机构将部分客户数据开放，诚邀大家帮助他们建立流失预测模型来预测可能流失的客户。

二、赛事任务

给定某电信机构实际业务中的相关客户信息，包含69个与客户相关的字段，其中“是否流失”字段表明客户会否会在观察日期后的两个月内流失。任务目标是通过训练集训练模型，来预测客户是否会流失，以此为依据开展工作，提高用户留存。

三、赛题数据

赛题数据由训练集和测试集组成，总数据量超过25w，包含69个特征字段。为了保证比赛的公平性，将会从中抽取15万条作为训练集，3万条作为测试集，同时会对部分字段信息进行脱敏。

四、评估标准

本次竞赛的评价标准采用AUC指标，正样本为1，评估代码参考：

 五、赛题baseline

1.导入模块

import pandas as pd  # 用来导入csv文件
# import os  # 未用到的包
# import gc  # 未用到的包
import lightgbm as lgb  # LightGBM是一个梯度提升框架，使用基于树的学习算法，在xgboost上做了改进，速度更快，集成学习框架中的梯度提升算法
import xgboost as xgb  # 极度梯度提升，集成学习框架中的梯度提升算法
from catboost import CatBoostRegressor  # 一种集成学习算法
# from sklearn.linear_model import SGDRegressor, LinearRegression, Ridge  # 未用到的包
# from sklearn.preprocessing import MinMaxScaler  # 未用到的包
# from gensim.models import Word2Vec  # 未用到的包
# import math  # 未用到的包
import numpy as np  # 用来存储和处理大型矩阵
# from tqdm import tqdm  # 进度条库，未用到的包
from sklearn.model_selection import StratifiedKFold, KFold
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, log_loss   # roc_auc_score，即使用AUC作为评估指标
# import matplotlib.pyplot as plt  # 未用到的包
# import time  # 未用到的包
import warnings
warnings.filterwarnings('ignore')

2.数据预处理

# 1数据预处理
# pd.set_option('display.max_columns', None)  # 设置显示时显示所有列
train = pd.read_csv('train.csv')  # 训练集，带有“是否流失”标签
test = pd.read_csv('test.csv')   # 测试集
# print(train.head())  # 读取前5行数据
# train.isnull().any() # 检测是否有缺失数据,本题不必验证
# 链接数据
# axis=0表示按行拼接train(15万行)和test（3万行），拼接后的data有18万行
# ignore_index=True表示忽略两个数据集原有的索引（分别是0-149999；0-29999），从头到尾重新赋索引值（0-179999）
data = pd.concat([train, test], axis=0, ignore_index=True)

3.训练数据/测试数据准备

# 2训练数据/测试数据准备
# 导出特征名称
features = [f for f in data.columns if f not in ['是否流失','客户ID']]  # 获取67个客户字段,不包括'是否流失','客户ID'字段
 
train = data[data['是否流失'].notnull()].reset_index(drop=True)  # 取拼接数据集里的训练集，并重置索引
test = data[data['是否流失'].isnull()].reset_index(drop=True)  # 取拼接数据集里的测试集，并重置索引
 
# 分别对测试集，训练集提取特征数据
x_train = train[features]  # 处理后的训练集，字段67个，非原来的69个（数据的多维特征）
x_test = test[features]  # 处理后的测试集，字段67个，非原来的68个
 
# 提取训练集标签
y_train = train['是否流失']  # 获取训练集中字段'是否流失'的值，共15万个（标注信息）

4.构建模型

# 3构建模型 clf:classifier 分类器（有监督学习就是找一个x_train到y_train的映射）
# clf：为模型库函数，train_x：训练数据集特征数据,train_y：训练数据集标签
# test_x：测试集特征数据,clf_name：选择不同的模型，对应不同的模型名称
def cv_model(clf, train_x, train_y, test_x, clf_name):
    folds = 5  # 代表交叉验证中的折数
    seed = 2022  # 随机种子
    # 交叉验证函数，这里是5折随机交叉验证
    kf = KFold(n_splits=folds, shuffle=True, random_state=seed)
 
    # 声明变量train和test用于存储预测结果
    train = np.zeros(train_x.shape[0])
    test = np.zeros(test_x.shape[0])
 
    # 声明列表 cv_scores 用于存储每折交验证后结果得分
    cv_scores = []
    # 循环遍历每折交叉验证
    for i, (train_index, valid_index) in enumerate(kf.split(train_x, train_y)):
        print('************************************ {} ************************************'.format(str(i + 1)))
        # 提取对应的训练集特征数据、验证集特征数据及其对应标签
        trn_x, trn_y, val_x, val_y = train_x.iloc[train_index], train_y[train_index], train_x.iloc[valid_index], train_y[valid_index]
 
        # 根据模型名称开始判断选择相应模型
        if clf_name == "lgb":
            # 由于模型需要加载特定数据格式、类型，因此在此处完成数据格式、类型转换
            train_matrix = clf.Dataset(trn_x, label=trn_y)
            valid_matrix = clf.Dataset(val_x, label=val_y)
            '''
            params是一个字典，里面包含着训练中的参数关键字和对应的值，形式是params = {‘booster’:’gbtree’,’eta’:0.1}
            params中参数解释:
            objective: 目标函数的选择要根据问题确定，如果是回归问题 ，一般是 reg:linear , reg:logistic , count:poisson 如果是分类问题，一般是binary:logistic ,rank:pairwise
            booster:表示应用的弱学习器的类型, 推荐用默认参数可选的有gbtree, dart, gblinear
               a: gblinear是线性模型，表现很差，接近一个LASSO
               b: dart是树模型的一种，思想是每次训练新树的时候，随机从前m轮的树中扔掉一些，来避免过拟合
               gbtree即是论文中主要讨论的树模型，推荐使用
            eval_metric:根据objective而定
               a: 模型性能度量方法，主要根据objective而定，也可以自定义一些，下面列举一些常见的
               b: rmse : root mean square error     也就是平方误差和开根号
               c: mae  : mean absolute error        误差的绝对值再求平均
               d: auc  : area under curve           roc曲线下面积
               e: aucpr: area under the pr curve    pr曲线下面积
            gamma:叶子节点分裂时所需要的最小的损失减少量，这个值越大，叶子节点越难分裂，所以算法就越保守
            min_child_weight:
               a: 最小的叶子节点权重
               b: 在普通的GBM中，叶子节点样本没有权重的概念，其实就是等权重的，也就相当于叶子节点样本个数
               c: 越小越没有限制，容易过拟合，太高容易欠拟合	
            max_depth: 
               a: 树的最大深度
               b: 这个值对结果的影响算是比较大的了，值越大，树的深度越深，模型的复杂度就越高，就越容易过拟合
               c: 注意如果这个值被设置的较大，会吃掉大量的内存
               d: 一般来说比价合适的取值区间为[3, 10]
            lambda: 损失函数中的L2正则化项的系数，类似RidgeRegression，减轻过拟合
            sub_sample:
               a: 样本抽样比例
               b: 在每次训练的随机选取sub_sample比例的样本来作为训练样本
            colsample_by*:
               a: 这里实际上有3个参数，借助了随机森林的特征抽样的思想，3个参数可以同时使用
               b: colsample_bytree   更常用，每棵树的特征抽样比例
               c: colsample_bylevel  每一层深度的树特征抽样比例
               d: colsample_bynode   每一个节点的特征抽样比例	
            eta: 就是常说的学习速率，控制每一次学习的权重缩减，给后来的模型提供更多的学习空间			
            tree_method:
               xgboost中使用的树约束算法。xgboost的分布式训练支持 hist 和 approx。
               a: auto：使用启发式选择最快的方法。中小数据集：精确的贪心算法；大数据集：近似算法
               b: exact：精确的贪心算法
               c: approx：近似的贪心算法，使用分位数图和梯度直方图
               d: hist: 快速直方图优化近似贪心算法，它使用了一些性能改进，比如垃圾缓存
               e: gpu_exact: exact 算法的GPU实现
               f: gpu_hist:hist 算法的GPU实现	
            nthread:
               a: 训练过程中的并行线程数
               b: 如果用的是sklearn的api，那么使用n_jobs来代替
            seed: 随机数种子
            silent: 不推荐使用，推荐使用verbosity参数来代替，功能更强大
            train_matrix: 训练的数据
            num_boost_round: 这是指提升迭代的个数
            evals: 这是一个列表，用于对训练过程中进行评估列表中的元素。形式是evals = [(dtrain,’train’),(dval,’val’)]或者是evals = [(dtrain,’train’)],
                  对于第一种情况，它使得我们可以在训练过程中观察验证集的效果。
            verbose_eval: (可以输入布尔型或数值型)，也要求evals 里至少有一个元素。如果为True ,则对evals中元素的评估结果会输出在结果中；如果输入数字，假设为5，则每隔5个迭代输出一次。
            early_stopping_rounds:
            早期停止次数 ，假设为100，验证集的误差迭代到一定程度在100次内不能再继续降低，就停止迭代。
            这要求evals 里至少有一个元素，如果有多个，按最后一个去执行。返回的是最后的迭代次数（不是最好的）。
            如果early_stopping_rounds存在，则模型会生成三个属性，bst.best_score,bst.best_iteration,和bst.best_ntree_limit。
            '''
            params = {
                'boosting_type': 'gbdt',
                'objective': 'binary',
                'metric': 'auc',
                'min_child_weight': 5,
                'num_leaves': 2 ** 5,
                'lambda_l2': 10,
                'feature_fraction': 0.7,
                'bagging_fraction': 0.7,
                'bagging_freq': 10,
                'learning_rate': 0.2,
                'seed': 2022,
                'n_jobs': -1
            }
            # 训练模型
            model = clf.train(params, train_matrix, 50000, valid_sets=[train_matrix, valid_matrix],categorical_feature=[], verbose_eval=3000, early_stopping_rounds=200)
            # 利用训练好的模型对验证集数据进行预测，验证模型效果
            val_pred = model.predict(val_x, num_iteration=model.best_iteration)
            # 利用训练好的模型对测试集数据进行预测
            test_pred = model.predict(test_x, num_iteration=model.best_iteration)
 
            print(list(sorted(zip(features, model.feature_importance("gain")), key=lambda x: x[1], reverse=True))[:20])
 
        if clf_name == "xgb":
            # 由于模型需要加载特定数据格式、类型，因此在此处完成数据格式、类型转换
            train_matrix = clf.DMatrix(trn_x, label=trn_y)
            valid_matrix = clf.DMatrix(val_x, label=val_y)
            test_matrix = clf.DMatrix(test_x)
            # params为模型中指定参数，可参照上方关于xgb模型参数解释
            params = {'booster': 'gbtree',  # 使用的弱学习器，有两种选择：gbtree(默认)和gblinear;
                                            # gbtree是基于树形的提升计算，gblinear是基于线性模型的提升计算
                      'objective': 'binary:logistic',  # 二分类的logistic,objective用来定义学习任务及相应的损失函数
                      'eval_metric': 'auc',
                      'gamma': 1,  # 叶子节点进行划分时需要损失函数价绍德最小值
                      'min_child_weight': 1.5,
                      'max_depth': 5,  # 树的最大深度，缺省值为6
                      'lambda': 10,  # 正则化权重
                      'subsample': 0.7,  # 训练模型的样本占总样本的比例，用于防止过拟合
                      'colsample_bytree': 0.7,  # 建立树时对特征进行采样的比例
                      'colsample_bylevel': 0.7,
                      'eta': 0.2,  # 加法模型中使用的收缩步长
                      'tree_method': 'exact',
                      'seed': 2020,  # 随机数种子，随便取
                      'nthread': 36,  # XGBoost运行时的线程数，缺省时是当前系统获得的最大线程数
                      "silent": True,  # True表示以缄默方式运行，False则打印运行时的信息（默认）
                      }
 
            watchlist = [(train_matrix, 'train'), (valid_matrix, 'eval')]
            # xgboost模型训练
            model = clf.train(params, train_matrix, num_boost_round=50000, evals=watchlist, verbose_eval=3000,early_stopping_rounds=200)
            # 利用训练好的模型对验证集数据进行预测，验证模型效果
            val_pred = model.predict(valid_matrix, ntree_limit=model.best_ntree_limit)
            # 利用训练好的模型对测试集数据进行预测
            test_pred = model.predict(test_matrix, ntree_limit=model.best_ntree_limit)
 
        if clf_name == "cat":
            params = {'learning_rate': 0.2,
                      'depth': 5,
                      'l2_leaf_reg': 10,
                      'bootstrap_type': 'Bernoulli',
                      'od_type': 'Iter',
                      'od_wait': 50,
                      'random_seed': 11,
                      'allow_writing_files': False
                      }
 
            model = clf(iterations=20000, **params)
            model.fit(trn_x, trn_y, eval_set=(val_x, val_y),cat_features=[], use_best_model=True, verbose=3000)
 
            val_pred = model.predict(val_x)
            test_pred = model.predict(test_x)
 
        train[valid_index] = val_pred
        test = test_pred / kf.n_splits
        cv_scores.append(roc_auc_score(val_y, val_pred))
 
        print(cv_scores)
 
    # 输出K折交叉验证结果
    print("%s_scotrainre_list:" % clf_name, cv_scores)
    # 输出K折交叉验证结果的均值
    print("%s_score_mean:" % clf_name, np.mean(cv_scores))
    # 输出K折交叉验证结果标准差
    print("%s_score_std:" % clf_name, np.std(cv_scores))
    return train, test
 
# 定义lgb模型，进行调用
def lgb_model(x_train, y_train, x_test):
    lgb_train, lgb_test = cv_model(lgb, x_train, y_train, x_test, "lgb")
    return lgb_train, lgb_test
 
# 定义xgb模型，进行调用
def xgb_model(x_train, y_train, x_test):
    xgb_train, xgb_test = cv_model(xgb, x_train, y_train, x_test, "xgb")
    return xgb_train, xgb_test
 
# 定义cat模型，进行调用
def cat_model(x_train, y_train, x_test):
    cat_train, cat_test = cv_model(CatBoostRegressor, x_train, y_train, x_test, "cat")
    return cat_train, cat_test
 
lgb_train, lgb_test = lgb_model(x_train, y_train, x_test)

5.提交结果

# 4提交结果,保存测试集预测结果至test_sub.csv文件中
test['是否流失'] = lgb_test
test[['客户ID','是否流失']].to_csv('test_sub.csv', index=False)

分别使用LightGBM,XGBoost,CATBOOST三种算法运行了代码，以下是提交到网站后获得的分数：

LightGBM算法设置交叉验证折数分别为5，7的结果

XGBoost算法设置交叉验证折数分别为5，7的结果

CATBOOST算法结果

 总结：

由返回分数可见，LightGBM算法是三个算法中最优秀的，而且增加交叉验证折数能获得更好的结果，但是代码运行时长也会增加，最长的一次差不多两个小时。通过对本次竞赛代码的学习，我对机器学习解决问题的流程有了具体的认识。此外，之后要学会利用云端的免费算力资源帮助自己训练模型，否则自己的笔记本很难承受长时间的cpu满负荷运行，比如Kaggle Kernels。后续还需要通过特定的任务来了解更多不同的模型，做好总结。