电信用户流失任务一

导入包

import pandas as pd
import os
import gc
import lightgbm as lgb
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
import matplotlib.pyplot as plt
import time
import warnings
warnings.filterwarnings('ignore')#警告过滤

读取数据

 # 从csv文件中读取数据
train = pd.read_csv('train.csv')#训练集
test = pd.read_csv('test.csv')#测试集
data = pd.concat([train, test], axis=0, ignore_index=True)
len(data)
# 导出特征列名称
features = [f for f in data.columns if f not in ['是否流失','客户ID']]
# 重置索引后,drop参数默认为False,想要删除原先的索引列要置为True.
# 此处训练数据集中  是否流失  是应当不为空（有标签的），而测试集是无标签的，因此此处对数据集进行拆分，分为训练集和测试集并对其索引进行重置。
train = data[data['是否流失'].notnull()].reset_index(drop=True)#用索引重置生成一个新的DataFrame或Series
test = data[data['是否流失'].isnull()].reset_index(drop=True)
# 分别对测试集、训练集提取特征数据
x_train = train[features]
x_test = test[features]
# 提取训练集是否流失（标签）
y_train = 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 == "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 = {'booster': 'gbtree',
                      'objective': 'binary:logistic',
                      'eval_metric': 'auc',
                      'gamma': 1,
                      'min_child_weight': 1.5,
                      'max_depth': 5,
                      'lambda': 10,
                      'subsample': 0.7
                      'colsample_bytree': 0.7,
                      'colsample_bylevel': 0.7,
                      'eta': 0.2,
                      'tree_method': 'exact',
                      'seed': 2020,
                      'nthread': 36,
                      "silent": True,
                      }
            
            watchlist = [(train_matrix, 'train'),(valid_matrix, 'eval')]
			# 训练模型
            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 == "lgb":
        	# 由于模型需要加载特定数据格式、类型，因此在此处完成数据格式、类型转换
            train_matrix = clf.Dataset(trn_x, label=trn_y)
            valid_matrix = clf.Dataset(val_x, label=val_y)
            # params为模型中指定参数，可参照上方关于xgb模型参数解释自行查询，此处暂时不详细解释
            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)
            # 输出平均增益排名前20的特征及其收益
            # gain: 该特征在它所有分裂使用中带来的平均增益
            print(list(sorted(zip(features, model.feature_importance("gain")), key=lambda x: x[1], reverse=True))[:20])
                
        
        if clf_name == "cat":
        	# params为模型中指定参数，可参照上方关于xgb模型参数解释自行查询，此处暂时不详细解释
            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)