利用逻辑回归进行用户流失预测分析_基于逻辑回归来预测用户充值流失

1.项目背景

客户流失是所有与消费者挂钩行业都会关注的点。因为发展一个新客户是需要一定成本的，一旦客户流失，除了浪费拉新成本，还需要花费更多的用户召回成本。
所以，电信行业在竞争日益激烈当下，如何挽留更多用户成为一项关键业务指标。为了更好运营用户，这就要求要了解流失用户的特征，分析流失原因，预测用户流失，确定挽留目标用户并制定有效方案。

2.明确分析问题

1. 分析用户特征与流失的关系。
2. 从整体情况看，流失用户普遍具有哪些特征？
3. 尝试找到合适的模型预测流失用户。
4. 针对性给出增加用户黏性、预防流失的建议。

3.数据理解

本数据集来源Kaggle上公开的某电信公司的用户数据，共包含7043条数据，共21个字段。

4.数据清洗

数据清洗的“完全合一”规则：

• 完整性：单条数据是否存在空值，统计的字段是否完善。
• 全面性：观察某一列的全部数值，通过常识来判断该列是否有问题，比如：数据定义、单位标识、数据本身。
• 合法性：数据的类型、内容、大小的合法性。比如数据中是否存在非ASCII字符，性别存在了未知，年龄超过了150等。
• 唯一性：数据是否存在重复记录，因为数据通常来自不同渠道的汇总，重复的情况是常见的。行数据、列数据都需要是唯一的。

4.1数据导入

# 导入数据分析需要的包
import pandas as pd
import numpy as np
# 可视化包
import seaborn as sns
sns.set(style="whitegrid")
import matplotlib.pyplot as plt
%matplotlib inline
# 忽略警告信息
import warnings
warnings.filterwarnings('ignore')
# 显示中文
plt.rcParams["font.sans-serif"] = ["SimHei"]
plt.rcParams["axes.unicode_minus"] = False
# 导入数据集
df=pd.read_csv('./WA_Fn-UseC_-Telco-Customer-Churn.csv')
# 查看数据
df.head(5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.2查看数据类型

df.info()
1

MonthlyCharges和TotalCharges都为费用，类型都应该为数值,
但通过查看发现TotalCharges为object对象类型，需要转化数值类型。

#强制转换数字(包括字符串)
df['TotalCharges']=df['TotalCharges'].apply(pd.to_numeric,errors='coerce')
#df['TotalCharges'] = df['TotalCharges'].convert_objects(convert_numeric=True)
df['TotalCharges'].dtypes
# 输出结果
dtype('float64')
1
2
3
4
5
6

# convert_numeric=True 表示强制转换数字（包括字符串），不可转换的值Nan
df['MonthlyCharges']=df['MonthlyCharges'].convert_objects(convert_numeric=True)                                                     
df['MonthlyCharges'].dtypes
# 输出结果
dtype('float64')
1
2
3
4
5

4.3缺失值处理

# 查看缺失值
df.isnull().sum()
1
2

# 定位缺失值所在行，查看具体情况
df[df['TotalCharges']!=df['TotalCharges']][['tenure','MonthlyCharges','TotalCharges']]
1
2

分析：
发现这11个用户tenure（入网时常）为0，推测是当月新入网用户。
根据一般经验，用户即使在注册的当月流失，也需缴纳当月费用。
因此将这11个用户入网时长改为1，将总消费额填充为月消费额，符合实际情况。

• 将总消费额填充为月消费额

#将总消费额填充为月消费额
df.loc[:,'TotalCharges'].replace(np.nan,df.loc[:,'MonthlyCharges'],inplace=True)
#查看是否替换成功
df[df['tenure']==0][['tenure','MonthlyCharges','TotalCharges']]
1
2
3
4

• 将‘tenure’入网时长从0修改为1

# 将‘tenure’入网时长从0修改为1
df.loc[:,'tenure'].replace(to_replace=0,value=1,inplace=True)
1
2

4.4数据归一化处理

对Churn 列中的值 Yes和 No分别用 1和 0替换，方便后续处理

df['Churn'].replace( 'Yes', 1,inplace = True)
df['Churn'].replace( 'No',  0,inplace = True)
df['Churn'].head()
1
2
3

# 保存数据集
df.to_csv('./Telecom_customer churn1.csv')
1
2

5.流失用户特征分析

根据用户主要特征。将用户属性分为三类，用户属性、服务属性及合同属性。

• 查看客户总体流失情况

# 查看总体客户流失情况
churnvalue = df["Churn"].value_counts()
labels = df["Churn"].value_counts().index
plt.pie(churnvalue,
        labels=["未流失","流失"],
        explode=(0.1,0),
        autopct='%.2f%%', 
        shadow=True,)
plt.title("客户流失率比例",size=24)
plt.show()
1
2
3
4
5
6
7
8
9
10

分析：
从饼形图中看出，流失客户占总客户数的四分之一比例，流失率达26.54%

5.1用户属性分析

fig, axes = plt.subplots(2, 2, figsize=(12,12))
plt.subplot(2,2,1) 
# palette参数表示设置颜色
gender=sns.countplot(x='gender',hue="Churn",data=df,palette="Pastel2") 
plt.xlabel("性别",fontsize=16)
plt.ylabel('count',fontsize=16)
plt.tick_params(labelsize=12)     # 设置坐标轴字体大小
plt.title("Churn by Gender",fontsize=18)

plt.subplot(2,2,2)
seniorcitizen=sns.countplot(x="SeniorCitizen",hue="Churn",data=df,palette="Pastel2")
plt.xlabel("年龄（0代表是年轻人，1代表是老年人）")
plt.title("Churn by Senior Citizen",fontsize=18)
plt.ylabel('count',fontsize=16)
plt.tick_params(labelsize=12)   # 设置坐标轴字体大小

plt.subplot(2,2,3)
partner=sns.countplot(x="Partner",hue="Churn",data=df,palette="Pastel2")
plt.xlabel("婚姻状态（yes代表已婚，no代表未婚）")
plt.title("Churn by Partner",fontsize=18)
plt.ylabel('count',fontsize=16)
plt.tick_params(labelsize=12)   # 设置坐标轴字体大小

plt.subplot(2,2,4)
dependents=sns.countplot(x="Dependents",hue="Churn",data=df,palette="Pastel2")
plt.xlabel("经济能力（yes代表经济独立，no代表未独立）")
plt.title("Churn by Dependents",fontsize=18)
plt.ylabel('count',fontsize=16)
plt.tick_params(labelsize=12)   # 设置坐标轴字体大小
plt.tight_layout()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

分析：

• 用户流失与性别基本无关，差异性较小；

• 年老客户用户量相对较少，但流失率较高；

• 未婚用户流失率高于已婚用户；

• 经济能力未独立的用户流失率高于经济能力独立用户

5.2服务属性

查看网络安全服务、在线备份业务、设备保护业务、技术支持服务、
网络电视、网络电影和无互联网服务对客户流失率的影响。

covariables=["OnlineSecurity", "OnlineBackup", "DeviceProtection", "TechSupport", "StreamingTV", "StreamingMovies"]
fig,axes=plt.subplots(2,3,figsize=(20,12))
for i, item in enumerate(covariables):
    '''
    0,'OnlineSecurit'
    1,'OnlineBackup'
    '''
    plt.subplot(2,3,(i+1))
    ax=sns.countplot(x=item,hue="Churn",data=df,palette="Set2",order=["Yes","No","No internet service"])
    plt.xlabel(str(item),fontsize=16)
    plt.tick_params(labelsize=14)     # 设置坐标轴字体大小
    plt.title("Churn by "+ str(item),fontsize=20)
    i=i+1
plt.tight_layout()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

分析：
在这六个服务属性中，开通相关服务的用户流失率较低，
说明有这些方面需求的客户对此服务还比较满意，客户群体也比较稳定。
No internetserive这部分客户群体流失率基本相同，且相对较低。

5.3合同属性

• 查看合同签订方式对用户流失的影响

fig = plt.figure(figsize=(12,8))
sns.barplot(x="Contract",
            y="Churn", 
            data=df, 
            palette="Pastel1", 
            order= ['Month-to-month', 
                    'One year', 'Two year'])
plt.title("Churn by Contract type",fontsize=20)
plt.xlabel('Contract',fontsize=16)
plt.ylabel('Churn',fontsize=16)
plt.tick_params(labelsize=13)     # 设置坐标轴字体大小
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12

分析：
从柱状图中看出，合同期限越长，流失率越低，一部分原因是选择长期合同的客户原本就比较稳定，
另外一个原因是长期合同具有长期约束率，在客户签订合同时，可以针对一次签订长期合同的客户进行优惠促销。

• 查看付款方式对用户流失率的影响

plt.figure(figsize=(12,8))
sns.barplot(x="PaymentMethod",y="Churn", data=df, palette="Pastel1", order= ['Bank transfer (automatic)', 'Credit card (automatic)', 'Electronic check','Mailed check'])
plt.title("Churn by PaymentMethod type",fontsize=20)
plt.xlabel('PaymentMethod',fontsize=16)
plt.ylabel('Churn',fontsize=16)
plt.tick_params(labelsize=13)     # 设置坐标轴字体大小
plt.show()
1
2
3
4
5
6
7

分析：
在四种支付方式中，使用Electronic check的用户流失率最高，其他三种支付方式基本持平，因此可以推断电子账单在设计上影响用户体验。

• 查看正常用户与流失用户在月消费金额上的差别

plt.figure(figsize=(10,6))
g = sns.FacetGrid(data = df,hue = 'Churn', height=4, aspect=3)
g.map(sns.distplot,'MonthlyCharges',norm_hist=True)
g.add_legend()
plt.ylabel('density',fontsize=16)
plt.xlabel('MonthlyCharges',fontsize=16)
plt.tick_params(labelsize=13)     # 设置坐标轴字体大小
plt.tight_layout()
plt.show()
1
2
3
4
5
6
7
8
9

分析：
从上图看出，月消费额大约在70-110这个区间内的用户流失率相对较高。

• 查看正常用户与流失用户在总消费金额上的差别

g = sns.FacetGrid(data = df,hue = 'Churn', height=4, aspect=3)
g.map(sns.distplot,'TotalCharges',norm_hist=True)
g.add_legend()
plt.ylabel('density',fontsize=16)
plt.xlabel('TotalCharges',fontsize=16)
plt.tick_params(labelsize=13)     # 设置坐标轴字体大小
plt.show()
1
2
3
4
5
6
7

分析：
从上图看出，总消费金额越多，客户流失率会相对较低,
说明当客户对此产品形成一定消费习惯后，忠诚度会升高。

6.用户流失预测

对数据集进一步清洗和提取特征，通过特征选取对数据进行降维，采用机器学习模型应用于测试数据集，
然后对构建的分类模型准确性进行分析。

7 数据预处理

#导入数据分析需要的包
import pandas as pd
import numpy as np
#可视化包
import seaborn as sns
sns.set(style="whitegrid")
import matplotlib.pyplot as plt
%matplotlib inline
#忽略警告信息
import warnings
warnings.filterwarnings('ignore')
plt.rcParams["font.sans-serif"] = ["SimHei"]
plt.rcParams["axes.unicode_minus"] = False
#导入数据集
df = pd.read_csv('./Telecom_customer churn1.csv')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# CustomerID表示每个客户的标识，对后续建模不影响，这里选择删除CustomerID列
customerID=df['customerID']
df.drop("customerID",axis=1, inplace=True)
df.drop('Unnamed: 0',axis=1,inplace=True)
df.head() 
1
2
3
4
5

7.1 特征编码

特征主要分为连续特征和离散特征，其中离散特征根据特征之间是否有大小关系又细分为两类。

• 连续特征：“tenure”、“MonthlyCharges”、“TotalCharges”，一般采用归一标准化方式处理。
• 离散特征：特征之间没有大小关系，如：PaymentMethod：[bank transfer，credit card，electronic check，mailed check]，付费方式之间没有大小关系，一般采用one-hot编码。
• 离散特征：特征之间有大小关联，则采用数值映射。本数据集无此类特征。

7.1.1 连续特征编码

对tenure（在网时长），MonthlyCharges（月费用），TotalCharges（总费用）三个连续特征进行标准化处理，
使特征数据标准为1，均值为0，符合标准的正态分布，降低数值特征过大对预测结果的影响。

from sklearn.preprocessing import StandardScaler  
# 实例化一个转换器类
scaler = StandardScaler(copy=False)
# 调用fit_transform，其作用是先拟合数据，然后转化它将其转化为标准形式
scaler.fit_transform(df[['tenure','MonthlyCharges','TotalCharges']])
#利用transform函数实现标准化，作用是通过找中心和缩放等实现标准化
df[['tenure','MonthlyCharges','TotalCharges']]=scaler.transform(df[['tenure','MonthlyCharges','TotalCharges']])
df[['tenure','MonthlyCharges','TotalCharges']].head()
1
2
3
4
5
6
7
8

7.1.2 离散特征编码

# 查看对象类型字段中存在的值
def uni(columnlabel):
    # unique函数去除其中重复的元素，返回唯一值
    print(columnlabel,"--" ,df[columnlabel].unique())
    
dfobject=df.select_dtypes(['object'])
for i in range(0,len(dfobject.columns)):
    uni(dfobject.columns[i])
1
2
3
4
5
6
7
8

结合服务属性，发现No internet service（无互联网服务）对客户流失率影响很小，
这些客户不使用任何互联网产品，因此可以将No internet service 和 No 是一样的效果，
可以使用 No 替代 No internet service

df.replace(to_replace='No internet service', value='No', inplace=True)
df.replace(to_replace='No phone service', value='No', inplace=True)
#再次查看
for i in range(0,len(dfobject.columns)):
    uni(dfobject.columns[i])
1
2
3
4
5

7.1.3 使用Scikit-learn标签编码，将离散特征转换为整数编码

# 编码转换
from sklearn.preprocessing import LabelEncoder  
def labelencode(columnlabel):
    df[columnlabel] = LabelEncoder().fit_transform(df[columnlabel])
    
for i in range(0,len(dfobject.columns)):
    labelencode(dfobject.columns[i])
    
for i in range(0,len(dfobject.columns)):
    uni(dfobject.columns[i])
1
2
3
4
5
6
7
8
9
10

7.2 数据相关性分析

电信用户是否流失与各变量之间的相关性

plt.figure(figsize=(16,8))
df.corr()['Churn'].sort_values(ascending = False).plot(kind='bar')
plt.tick_params(labelsize=14)     # 设置坐标轴字体大小
plt.xticks(rotation=45)         # 设置x轴文字转向
plt.title("Correlations between Churn and variables",fontsize=20)
plt.show()
1
2
3
4
5
6

分析：
从上图可以直观看出，PhoneService 、gender这两个变量与churn目标变量相关性最弱。

7.3 特征选取

特征值选取时，去除相关性较弱的PhoneService 、gender两个变量。这里目标变量是churn。

# 特征选取
dropFea = ['gender','PhoneService']
df.drop(dropFea, inplace=True, axis =1)
# 深拷贝
X=df.copy()
X.drop(['Churn'],axis=1, inplace=True)
y=df["Churn"]
#查看预处理后的数据
X.head()
1
2
3
4
5
6
7
8
9

8 构建模型

8.1 样本不均衡处理

# 正常用户和流失用户数量分布
count_Churn = pd.value_counts(df['Churn']).sort_index()
plt.figure(figsize=(8,6))
count_Churn.plot(kind = 'bar')
plt.title("Churn histogram",size=20)
plt.xlabel("Churn")
plt.ylabel("Frequency")
1
2
3
4
5
6
7

从图中看出，该样本中正常用户和流失用户数量分布不平衡，建模过程中容易忽略数量较少的流失客户，模型出现一边倒的情况，如果模型不重视异常数据，就有悖我们建模的初衷，常用的解决方案有下采样和上采样，我们这里利用下采样方案进行处理。

下采样，简单的理解就是，两个唯一值，以数量最少值的个数为标准，随机对另外一个值选取相同个数，从而满足样本均衡化。本案例流失客户数为1869，从正常交易数据中同样选取1869个，各占比50%，总共3738个。

#下采样方案实现过程

#计算 Churn=1的样本的数量
number_records_Churn = len(df[df.Churn == 1]) 
# 取出Churn=1的样本对应的行索引
Churn_indices = np.array(df[df.Churn == 1].index) 
# 取出Churn=0样本对应的行索引
normal_indices = df[df.Churn == 0].index  

random_normal_indices = np.random.choice(normal_indices, number_records_Churn, replace = False) #随机选择和number_records_Churn一致的正常用户样本量
random_normal_indices = np.array(random_normal_indices) #转换成numpy的格式       

under_sample_indices = np.concatenate([Churn_indices,random_normal_indices])  #将正负样本拼接在一起

#下采样数据集
under_sample_data = df.iloc[under_sample_indices,:]

X_undersample = under_sample_data.iloc[:, under_sample_data.columns != 'Churn']  #下采样数据集的数据，可以理解为自变量
y_undersample = under_sample_data.iloc[:, under_sample_data.columns == 'Churn']  #下采样数据集的lable，可以理解为因变量

# 查看正负各自占比
print("Percentage of Churn_no: ", len(under_sample_data[under_sample_data.Churn == 0])/len(under_sample_data))
print("Percentage of Churn_yes: ", len(under_sample_data[under_sample_data.Churn == 1])/len(under_sample_data))
#查看总数
print("Total number of Churn in resampled data: ", len(under_sample_data))

'''
Percentage of Churn_no:  0.5
Percentage of Churn_yes:  0.5
Total number of Churn in resampled data:  3738
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

8.2 模型交叉验证

将数据集分为训练集和测试集，以帮助完成模型测试工作

# 将数据集分成训练集和测试集，比例为7:3
from sklearn.linear_model import LogisticRegression          # 逻辑回归
from sklearn.metrics import precision_score, recall_score, f1_score,accuracy_score
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import GridSearchCV  # 网格搜索
# 把整体数据集进行切分
# test_size = 0.3, 表示30%的数据作为测试集合，
# 剩余70%的数据作为训练集；state=0在切分时进行数据重洗牌的标识位。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state = 40)
print("原始训练集包含样本数量: ", len(X_train))
print("原始测试集包含样本数量:  ", len(X_test))
print("原始样本总数: ", len(X_train)+len(X_test))

'''
原始训练集包含样本数量:  4930
原始测试集包含样本数量:   2113
原始样本总数:  7043

下采样训练集包含样本数量:  2616
下采样测试集包含样本数量:   1122
下采样样本总数: 3738
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8.3 逻辑回归建模

# 逻辑回归建模
model = LogisticRegression(solver='liblinear', penalty='l1')
model.fit(X_train, y_train)

# 用建好的模型model在测试集进行验证
predictions = model.predict(X_test)
actual_score = accuracy_score(y_test, predictions)
print(actual_score)
'''
0.7846663511594889
'''
1
2
3
4
5
6
7
8
9
10
11

8.2.1 正则化惩罚

在机器学习任务中经常会遇到过拟合现象，最常见的情况就是随着模型复杂程度的提升，训练集效果越来越好，但是测试集效果反而越来越差。如果在训练集上得到的参数值忽高忽低，很可能导致过拟合，这时候就需要用到正则化惩罚，即惩罚数值较大的权重参数，降低它们对结果的影响。

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import KFold, cross_val_score
from sklearn.metrics import confusion_matrix,precision_recall_curve,auc,roc_auc_score,roc_curve,recall_score,classification_report

#Recall = TP/(TP+FN)
from sklearn.linear_model import LogisticRegression
# from sklearn.cross_validation import KFold, cross_val_score
from sklearn.metrics import confusion_matrix,recall_score,classification_report
from sklearn.model_selection import cross_val_predict, KFold, cross_val_score

#print(help(KFold))

def printing_Kfold_scores(x_train_data,y_train_data):
    #fold = KFold(len(y_train_data),5,shuffle=False)
    fold = KFold(5,shuffle=False)

    # 定义不同力度的正则化惩罚力度
    c_param_range = [0.01,0.1,1,10,100]
    # 展示结果用的表格
    results_table = pd.DataFrame(index = range(len(c_param_range),2), columns = ['C_parameter','Mean recall score'])
    results_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,start=1):
        for iteration, indices in enumerate(fold.split(x_train_data)):

            # 指定算法模型，并且给定参数
            #lr = LogisticRegression(C = c_param, penalty = 'l1')
            lr = LogisticRegression(C = c_param, penalty = 'l1',solver='liblinear')

            # 训练模型，注意索引不要给错，训练的时候一定传入的是训练集，所以X和Y的索引都是0
            lr.fit(x_train_data.iloc[indices[0],:],y_train_data.iloc[indices[0],:].values.ravel())

            # 建立好模型后，预测模型结果，这里用的就是验证集，索引为1
            y_pred_undersample = lr.predict(x_train_data.iloc[indices[1],:].values)

            # 有了预测结果之后就可以来进行评估了，这里recall_score需要传入预测值和真实值。
            recall_acc = recall_score(y_train_data.iloc[indices[1],:].values,y_pred_undersample)
            
            recall_accs.append(recall_acc)
            print('Iteration ', iteration,': 召回率 = ', recall_acc)


        # 当执行完所有的交叉验证后，计算平均结果
        results_table.loc[j,'Mean recall score'] = np.mean(recall_accs)
        j += 1
        print('')
        print('平均召回率 ', np.mean(recall_accs))
        print('')

    #找到最好的参数，Recall越高，效果越好
    best_c = results_table.loc[results_table['Mean recall score'].astype('float32').idxmax()]['C_parameter']

    # 打印最好的结果
    print('*********************************************************************************')
    print('效果最好的模型所选参数 = ', best_c)
    print('*********************************************************************************')

    return best_c

#交叉验证与不同参数结果
best_c = printing_Kfold_scores(X_train_undersample,y_train_undersample) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

8.2.2 混淆矩阵

上面已经训练好模型，这里利用混淆矩阵进行可视化展示分析。

# 定义混淆矩阵的画法
 def plot_confusion_matrix(cm, classes,
                              title='Confusion matrix',
                              cmap=plt.cm.Blues):
        """
        绘制混淆矩阵
        """
        plt.imshow(cm, interpolation='nearest', cmap=cmap)
        plt.title(title)
        plt.colorbar()
        tick_marks = np.arange(len(classes))
        plt.xticks(tick_marks, classes, rotation=0)
        plt.yticks(tick_marks, classes)

        thresh = cm.max() / 2.
        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
            plt.text(j, i, cm[i, j],
                     horizontalalignment="center",
                     color="white" if cm[i, j] > thresh else "black")

        plt.tight_layout()
        plt.ylabel('True label')
        plt.xlabel('Predicted label')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

传入实际预测结果，调用之前的逻辑回归模型，得到测试结果，再把数据的真实标签值传进去即可：

import itertools
# lr = LogisticRegression(C = best_c, penalty = 'l1')
lr = LogisticRegression(C = best_c, penalty = 'l1', solver='liblinear')
lr.fit(X_train,y_train.values.ravel())
y_pred = lr.predict(X_test.values)

# 计算所需值
cnf_matrix = confusion_matrix(y_test,y_pred)
np.set_printoptions(precision=2)

print("召回率: ", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))
# 绘制
class_names = [0,1]
plt.figure(figsize=(10,8))
plot_confusion_matrix(cnf_matrix
                      , classes=class_names
                      , title='Confusion matrix')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

真实为1的召回率：表示在流失客户中有多少能预测到，覆盖面的大小。

用公式表达即：
Recall=TN/(TN+FP)=438/(438+123)=0.78

召回率为 0.78，该分数还算理想。因为下采样时对原数据进行过处理，
模型最终要回归实际，这里需要在整体数据集的测试集进行评估效果，使模型更加可信

lr = LogisticRegression(C = best_c, penalty = 'l1', solver='liblinear')
lr.fit(X_train,y_train.values.ravel())
y_pred = lr.predict(X_test.values)

# 计算所需值
cnf_matrix = confusion_matrix(y_test,y_pred)
np.set_printoptions(precision=2)
print("召回率: ", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))

# 绘制
class_names = [0,1]
plt.figure(figsize=(10,8))
plot_confusion_matrix(cnf_matrix
                      , classes=class_names
                      , title='Confusion matrix')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在原始数据进行测试，得到的召回率为0.79，两者结果比较接近。

8.2.3 调整阈值

对于逻辑回归算法来说，我们还可以指定一个阈值，也就是说最终结果的概率是大于多少我们把它当成是正或者负样本。这里通过Sigmoid函数将得分值转换成概率值，默认情况下，模型都是以0.5为界限来划分类别：p>0.5为正例，p<0.5为负例。0.5是一个经验值，可以根据实际经验进行调整。我们指定0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9，9个不同阈值，分别查看模型效果。

# 用之前最好的参数来进行建模
# lr = LogisticRegression(C = 0.01, penalty = 'l1')
lr = LogisticRegression(C = 0.01, penalty = 'l1',solver='liblinear')

# 训练模型，还是用下采样的数据集
lr.fit(X_train_undersample,y_train_undersample.values.ravel())

# 得到预测结果的概率值
y_pred_undersample_proba = lr.predict_proba(X_test_undersample.values)

#指定不同的阈值
thresholds = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]

plt.figure(figsize=(10,10))

j = 1

# 用混淆矩阵来进行展示
for i in thresholds:
    y_test_predictions_high_recall = y_pred_undersample_proba[:,1] > i

    plt.subplot(3,3,j)
    j += 1

    cnf_matrix = confusion_matrix(y_test_undersample,y_test_predictions_high_recall)
    np.set_printoptions(precision=2)

    print("给定阈值为:",i,"时测试集召回率: ", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))

    class_names = [0,1]
    plot_confusion_matrix(cnf_matrix
                          , classes=class_names
                          , title='Threshold >= %s'%i)

'''
给定阈值为: 0.1 时测试集召回率:  0.9982174688057041
给定阈值为: 0.2 时测试集召回率:  0.9732620320855615
给定阈值为: 0.3 时测试集召回率:  0.9411764705882353
给定阈值为: 0.4 时测试集召回率:  0.8841354723707665
给定阈值为: 0.5 时测试集召回率:  0.7807486631016043
给定阈值为: 0.6 时测试集召回率:  0.6042780748663101
给定阈值为: 0.7 时测试集召回率:  0.36185383244206776
给定阈值为: 0.8 时测试集召回率:  0.0071301247771836
给定阈值为: 0.9 时测试集召回率:  0.0
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

通过对比九个不同阈值发现，当阈值越小时，召回率越高，但“误杀率”也比较高，实际意思不大。随着阈值增大，召回率降低，也就是“漏检”的数量增多，但“误杀率”也会降低。

如当阈值等于0.9时，有560个流失客户被正确预测，有1个流失客户没有被预测到，但有510个正常用户被误认为是流失用户，召回率为0.99，但精确率只有0.54；当阈值等于0.5时，有439个流失客户被正确预测，有122个流失客户没有被预测到，有170个正常用户被误认为是流失用户，召回率为0.78，准确率为0.73，准确率有所上升。

在预测客户流失中，理想状态时，所有的流失用户都被预测到(召回率)，这样我们就可以提前对这部分客户进行精细化运营，有效阻止客户流失，提高客户留存率；同时，也不存在正常用户被误判断为流失用户，减少运营成本，提高用户体验。但两者很难兼得，具体阈值调整需要结合实际业务，从实际业务出发，选择最优阈值。

9 建模

9.1 数据处理

9.1.1连续特征离散化

为了使模型更加稳定，使预测效果更好，对数值类型（tenure、MonthlyCharges）进行分析分箱操作。
其方法分为有监督分箱（卡方分箱、最小熵法分箱）和无监督分箱（等频分箱、等距分箱）。这里采用无监督分箱中的等频分箱进行操作。

df['tenure']=pd.qcut(df['tenure'],5)
df['MonthlyCharges']=pd.qcut(df['MonthlyCharges'],5)
1
2

9.1.2 One-Hot编码

前面，我们对区分度比较大的特征进行再次处理，如：Contract、InternetService、PaymentMethod等，同时这些变量为离散数据且数据内容标称属性，其数据本身不具有任何顺序意思。前面统一采用LabelEncode标签编码的方式欠妥。这里我们修正利用One-Hot独立编码的方式，构造虚拟变量。

sub_df=df.loc[:,['Contract','InternetService','PaymentMethod']] 
df = df.join(pd.get_dummies(sub_df))  #编码后并入数据集
1
2

9.2 模型调参 ——GridSearchCV（网格搜索）

GridSearchCV可以保证在指定的参数范围内自动找到精度最优的参数，但这也是网格搜索的缺陷所在，
它要求遍历所有可能参数的组合，在面对大数据集和多参数的情况下，非常耗时，适用范围有限。

本数据集体量较小，且决策树涉及参数较少，我们选择其中三个特征：criterion、max_depth和min_samples_split。

criterion：特征选择标准,可以使用"gini"或者"entropy"，前者代表基尼系数，后者代表信息增益。

max_depth：决策树最大深度。

min_samples_split：部节点再划分所需最小样本数。

#调用scikit-learn中集成的决策树tree
from sklearn import tree
#模型调参利器 gridSearchCV（网格搜索）
from sklearn.model_selection import GridSearchCV  
from sklearn import metrics
param_grid = {
    'criterion' : ['entropy','gini'], #特征选择标准
    'max_depth' : [2,3,4,5,6,7,8,9,10],            #决策树最大深度
    'min_samples_split' : [4,8,12,16,20,24,28]    #内部节点再划分所需最小样本数
}
clf = tree.DecisionTreeClassifier()
clfcv = GridSearchCV(estimator=clf,param_grid=param_grid,scoring='roc_auc',cv=4)
clfcv.fit(X_train,y_train)
clfcv.best_params_   #best_params_ ：最佳模型参数

'''
{'criterion': 'entropy', 'max_depth': 4, 'min_samples_split': 8}
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

9.3 构建决策树

利用最佳模型参数进行建树
决策树由结点和有向边组成。结点有两种类型：内部结点和叶结点，其中内部结点表示一个特征或属性，叶结点表示一个类。一般的，一棵决策树包含一个根结点、若干个内部结点和若干个叶结点。叶结点对应于决策结果，其他每个结点则对应于一个属性测试。

#利用balanced解决样本不均衡问题
clf= tree.DecisionTreeClassifier(criterion='entropy',
                                 max_depth=5,
                                 min_samples_split=4,
                                 class_weight="balanced")
clf.fit(X_train,y_train)
train_est = clf.predict(X_train)  #  用模型预测训练集的结果
train_est_p=clf.predict_proba(X_train)[:,1]  #用模型预测训练集的概率
test_est=clf.predict(X_test)  #  用模型预测测试集的结果
test_est_p=clf.predict_proba(X_test)[:,1]  #  用模型预测测试集的概率
from sklearn.metrics import accuracy_score
accuracy_score(y_test, clf.predict(X_test))

'''
0.7326076668244202
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ROC曲线中的表现

fpr_test, tpr_test, th_test = metrics.roc_curve(y_test, test_est_p)
fpr_train, tpr_train, th_train = metrics.roc_curve(y_train, train_est_p)
plt.figure(figsize=[6,6])
plt.plot(fpr_test, tpr_test, color='blue')
plt.plot(fpr_train, tpr_train, color='red')
plt.title('ROC curve')
plt.show()
1
2
3
4
5
6
7

从ROC曲线可以观察到训练数据和测试数据曲线重合度较高，拟合较好。

模型已经构建好，决策树有独特之处，就是可以展示决策过程。

#调用scikit-learn中集成的决策树tree
from sklearn import tree
clf = tree.DecisionTreeClassifier(max_depth=5) 
clf = clf.fit(X_train, y_train)

#展示决策树，定义函数
with open("No-Yes.dot", 'w') as f:
     f = tree.export_graphviz(clf,
                              out_file=f,
                              max_depth = 5,   #最优5层
                              impurity = True,
                              feature_names = list(X_train),
                              class_names = ["Churn_No", "Churn_Yes"],
                              rounded = True,
                              filled= True )

from subprocess import check_call
check_call(['C:/Program Files/Graphviz 2.44.1/bin/dot','-Tpng','No-Yes.dot','-o','No-Yes.png'])

from IPython.display import Image as PImage
from PIL import Image, ImageDraw, ImageFont
img = Image.open("No-Yes.png")
draw = ImageDraw.Draw(img)
img.save('output.png')
PImage("output.png")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这颗树从InternetService_Fiber optic这一分类特征的用户群体发展而来。可以明显发现，在网时长在0到6个月之间的年轻人群体很容易流失，但0到6个月之间中用Credit card (automatic)这种付款方式的群体则不容易流失；合同为Month-to-month形式的客户容易流失，但其中月缴费金额在(25.05, 58.83]之间的用户则比较稳定、不容易流失。

基于上述分析，给出运营建议：

• 新入网用户比较容易流失，尤其年轻用户群体，应当针对年轻人细化运营策略；
• 对比分析Credit card (automatic)该支付方式相对其他三类付款方式的优点，分析其独特成功之处，用来改善其他付款方式的服务，或者可以在支付时利用优惠减免方式让客户直接选择该支付方式；
• 月缴费额和开通服务功能直接相关，相对于没有开通服务的用户，开通享受多种附加增值服务的用户相对稳定，可以在客户签订时赠送用户体验资格，让更多的用户了解增值服务的好处，促使开通相关服务，从而提高客户留存度。

前面，我们只是单独知道Month-to-month、Fiber optic、在网时间短等这部分群体容易流失，具体相互之间决策关系并不清楚，我们可以通过决策树更加直观的挖掘相互关系，实现策略联动，这也是决策树可视化的独特好处。

10 结论和建议

流失用户特征：

• 用户属性：老年用户，未婚用户、经济未独立的用户更容易流失；

• 服务属性：未开通相关附加增值服务的用户更容易流失；

• 合同属性：签订的合同期较短，电子账单支付、月租费约70-110元的客户容易流失。

建议：

• 新入网用户比较容易流失，尤其年轻用户群体，应当针对年轻人细化运营策略；
• 对比分析Credit card (automatic)该支付方式相对其他三类付款方式的优点，分析其独特成功之处，用来改善其他付款方式的服务，或者可以在支付时利用优惠减免方式让客户直接选择该支付方式；
• 月缴费额和开通服务功能直接相关，相对于没有开通服务的用户，开通享受多种附加增值服务的用户相对稳定，可以在客户签订时赠送用户体验资格，让更多的用户了解增值服务的好处，促使开通相关服务，从而提高客户留存度。