9.1 电商B2C商铺新用户复购预测

1. 电商B2C模式介绍

1.1 电商主要业务模式

企业运转四⼤⻆⾊为产品、渠道、⽤户、运营，其盈利模式分别如下:

B2B

（也有写成 BTB，是Business-to-Business的缩写）是指企业与企业之间通过专⽤⽹络或Internet，进⾏数据信息的交换、传递，开展交易活动的商业模式

B2B【阿⾥巴巴、企业滴滴】 的盈利⽅式：⼴告、搜索、交易、增值服务、线下服务、商务合作

含有三要素：

1. 买卖：B2B ⽹站或移动平台为消费者提供质优价廉的商品，吸引消费者购买的同时促使更多商家的⼊驻。
2. 合作：与物流公司建⽴合作关系，为消费者的购买⾏为提供最终保障，这是 B2B 平台硬性条件之⼀。
3. 服务：物流主要是为消费者提供购买服务，从⽽实现再⼀次的交易。
   

C2C

个⼈与个⼈之间的电⼦商务

C2C【 闲⻥、转转、淘宝、拍拍、易趣】的盈利⽅式：通过为买卖双⽅搭建拍卖平台，按⽐例收取交易费⽤，或者提供平台⽅便个⼈在上⾯开店铺，以会员制的⽅式收费

B2C

是直接⾯向消费者销售产品和服务商业零售模式

B2C【 天猫、京东】的盈利方式：销售本⾏业产品、销售衍⽣产品、产品租赁、拍卖、销售平台、特许加盟、会员、上⽹服务、信息发布、为企业发布⼴告、为业内⼚商提供咨询服务

1.2 B2C主要业务功能

会员功能模块

商家后台功能模块

平台功能模块

平台盈利模式

1.3 商家数据分析师日常

1.3.1 日报周报（数据指标）

⽇报周报都是基于数据指标体系的，有了相应的指标体系，在⽇报周报中展示我们关⼼的指标即可。

1.3.2 数据整理（平台数据整理到数据库)

从后台对数据进⾏下载整理到⾃⼰的服务器（⽣意参谋.⽣E经)

1.3.3 活动分析（双11、双12、6.18等）

⽇常活动（拉新的，促活的）

活动之前要先了解⾃⼰的家底（流量情况，⽤户情况，商品情况）

活动前流量分析（主要知道⾃⼰店铺流量的主要来源）

在淘宝⾥还会有直通⻋、淘宝客等渠道

活动前商品分析（好的商品放到流量⻚⼤的⻚⾯即前⼏⻚）

活动前⽤户分析(看⼈下菜单)

活动中复盘（调整坑位）

活动后复盘（活动效果钱钱钱…）

1.3.4.运营诊断

步骤

1. 确定是否真的为异常
2. 会拆解（1同⼀维度相加，2不同维度相乘 3.其他类理清逻辑）
3. 对⽐后计算贡献率（排序后找原因）

异常类 ：转化率降低，转化率波动⼤，销售额下降，客单价下降，订单量下降等

⽬标类 : ⽇常达标效果，未达标或超额完成的原因

1.3 平台数据分析师⽇常

⾃营商品的分析和店铺级别的⼯作就⼀样了，除此之外还有商户分析，及平台功能性分析等

本课程就是在有⾜够商户，⼴告位在产品中安排较合理的情况下现要求⼴告收⼊较上半年⽉平均提升5%的业务需求，钻展这种定向投放，出价⽅式多的情况下，如何达到要求⽬标。

需要对⾼质量新⽤户预测功能的研发， 商家通过此功能对活动更热衷

2. 数据挖掘流程

2.1 项目知识图谱

缺失值处理的建议

1. 小于20%，采取方案补充（算法，均值，中位数、众数）
2. 20-50%，采取多值型离散化
3. 50-80%，采取二值型离散化
4. 大于80%，删除此属性

2.2 数据挖掘六⼤步骤

商业理解(Business understanding)：商业理解阶段应算是数据挖掘中最重要的⼀个部分，在这个阶段⾥我们需要明确商业⽬标、评估商业环境、确定挖掘⽬标以及产⽣⼀个项⽬计划。

理解数据(Data understanding)：数据是我们挖掘过程的“原材料”，在数据理解过程中我们要知道都有些什么数据，这些数据的特征是什么，可以通过对数据的描述性分析得到数据的特点。

数据准备(Date preparation)：在数据准备阶段我们需要对数据作出选择、清洗、重建、合并等⼯作。选出要进⾏分析的数据，并对不符合模型输⼊要求的数据进⾏规范化操作。

建模(Modeling)：建模过程也是数据挖掘中⼀个⽐较重要的过程。我们需要根据分析⽬的选出适合的模型⼯具，通过样本建⽴模型并对模型进⾏评估。

模型评估(Evaluation)：并不是每⼀次建模都能与我们的⽬的吻合，评价阶段旨在对建模结果进⾏评估，对效果较差的结果我们需要分析原因，有时还需要返回前⾯的步骤对挖掘过程重新定义。

结果部署(Deployment)：这个阶段是⽤建⽴的模型去解决实际中遇到的问题，它还包括了监督、维持、产⽣最终报表、重新评估模型等过程。

2.2.1 商业理解

商业理解(Business understanding)：商业理解阶段应算是数据挖掘中最重要的⼀个部分，在这个阶段⾥我们需要明确商业⽬标、评估商业环境、确定挖掘⽬标以及产⽣⼀个项⽬计划。

业务分级

企业级级别、 部⻔级级别、个⼈级别

商家业务分级

平台业务分级

商业⽬标与挖掘⽬标

2.2.2 理解数据

理解数据(Data understanding)：数据是我们挖掘过程的“原材料”，在数据理解过程中我们要知道都有些什么数据，这些数据的特征是什么，可以通过对数据的描述性分析得到数据的特点。

• 了解数据集⼤⼩，原始特征维度 shape
• 熟悉数据类型及是否有缺失值 astype
• 对缺失值过多的数据进⾏删除 80%缺失的
• 对各维度进⾏描述统计(业务异常) 查看数据是否符合正常分布 及是否有错误值

2.2.3 准备数据

数据准备(Date preparation)：在数据准备阶段我们需要对数据作出选择、清洗、重建、合并等⼯作。选出要进⾏分析的数据，并对不符合模型输⼊要求的数据进⾏规范化操作。主要是为建模准备数据，我们可以从数据预处理、特征提取、特征选择、特征衍⽣等⼏部分出发，整理如下

缺失值处理的⼏点建议：

1. ⼩于20%采取⽅案补充
2. 20%~50%之间采取多值离散化
3. 50%-80%之间采取⼆值离散化
4. ⼤于80的删除

不平衡数据处理

所谓不平衡数据集指的是数据集各个类别的样本量极不均衡。以⼆分类问题为例，假设正类的样本数量远⼤于负类的样本数量，通常情况下通常情况下把多数类样本的⽐例接近100:1这种情况下的数据称为不平衡数据。

我们可以认为⼆分类是 ⼀类⼩于10%时，数据为不平衡数据，其常⽤的处理⽅式如下

2.2.4 ⽣成模型

建模(Modeling)：我们需要根据分析⽬的选出适合的模型，以下是根据⽬标值（Y值）的类型确定模型，实现同⼀功能的模型有很多个，我们可以通过把各模型尝试下，⽤评估的⽅法来确定哪个模型针对于当前的数据更优秀。

2.2.5 模型评估

根据模型选择其模型评估⽅式

分类算法评估

真正(True Positive , TP)：被模型预测为正的正样本
假正(False Positive , FP)：被模型预测为正的负样本
假负(False Negative , FN)：被模型预测为负的正样本
真负(True Negative , TN)：被模型预测为负的负样本

真正率(True Positive Rate,TPR)：TPR=TP/(TP+FN)，即被预测为正的正样本数 /正样本实际数。
假正率(False Positive Rate,FPR) ：FPR=FP/(FP+TN)，即被预测为正的负样本数 /负样本实际数。
假负率(False Negative Rate,FNR) ：FNR=FN/(TP+FN)，即被预测为负的正样本数 /正样本实际数。
真负率(True Negative Rate,TNR)：TNR=TN/(TN+FP)，即被预测为负的负样本数 /负样本实际数。

准确率（Accuracy） = (TP+TN)/(TP+FN+FP+TN)

精确率（Precision） = TP/(TP+FP) 【预测正确的正样本，预测出是正的⾥⾯有多少真正是正的，也称查准率】

召回率（Recall）= TP/(TP+FN) 【实际正样本中，分类器能预测出多少。与真正率相等，可理解为查全率】

F1 score = 2 * Precision * Recall/（Precision+ Recall) 【F值是精确率和召回率的调和值，更接近于两个数较⼩的那个，所以精确率和召回率接近时，F值最⼤】

AUC 【被定义为ROC曲线下的⾯积，AUC值越⼤的分类器，性能越好】

roc 曲线

X轴 FPR , Y轴 TPR(召回率,查全率)

AUC = 1 最理想； 0.7~0.9 准去率⽐较⾼的了； 0.5 ⽆诊断价值

得到概率, 默认阈值0.5

roc曲线作⽤:1. 确定阈值, 2.得到AUC⾯积

聚类评估（最优簇数确定）

1）误差平⽅和（SSE)—刻画的簇内的凝聚程度：

ｍ为簇的中⼼点、p 为簇内的点、c 为⼀个簇、 k为簇的个数
肘点法则：下降率突然变缓时即认为是最佳的k值 (随着着簇数越多,SSE越⼩)

2）轮廓系数(SI)：
SI取值为[-1, 1]，其值越⼤越好

3）CH系数（Calinski-Harabasz Index）：

ui为各簇的均值、u为总均值、 xi为簇内各点
VRC越⼤意味着聚类质量越好

回归评估

Y 值(⽬标值) 为连续型, (线性回归指数回归 集成算法)

MAE（平均平⽅误差）⼜被称为 L1范数损失 【和本身的⽬标值有关系，不同数据源不能对⽐模型的优劣】

RMSE（平⽅根误差） 和本身的⽬标值有关系，不同数据源不能对⽐模型的优劣】

R^2 判定系数

注：SSR 回归平⽅和 ， SSE残差平⽅和， SST 总离差平⽅和。

3. 新⽤户复购预测实战

3.1 商业理解

在有⾜够商户，⼴告位在产品中安排较合理的情况下现要求⼴告收⼊较上半年⽉平均提升5%的业务需求，钻展这种定向投放，出价发⽅式多的情况下，如何达到要求⽬标。

拆解提升⼴告收⼊问题

⽀持站内⼴告购买的产品矩阵【钻展为例】

业务思路

商户运营⾯临的的困境 1. ⽤户来了就⾛ 2. 对运营活动有依赖，有活动就来，没活动就不来 3.运营活动带不来预期效果

对新⽤户复购预测新功能模块的使⽤，维护好新⽤户，使其发挥公告的价值，从⽽提⾼活动的ROI

通过模块功能加对⼴告的需求实现⼴告收⼊的提升

解决问题流程

业务分级： 部⻔级别（产品部⻔）

商业⽬标： 提⾼⼴告收⼊，新功能为预测新⽤户复购情况，提⽣⽤户价值，从⽽促使商购买更多的⼴告。

挖掘⽬标：预测对于指定商家的新买家将来是否会成为忠实客户，即需要预测这些新买家在6个⽉内再次从同⼀商家购买商品的概率。

3.2 理解数据

电商⽤户信息表

字段名	备注
user_id	买家ID
age_range	⽤户年龄范围。<18岁为1；[18,24]为2； [25,29]为3； [30,34]为4；[35,39]为5；[40,49]为6； > = 50时为7和8; 0和NULL表示未知
gender	⽤户性别。0表示⼥性，1表示男性，2和NULL表示未知

数据描述

424170个⽤户中，性别和年龄段均有缺失值，总体数据量⾜够，我们把缺失的数据直接删除就好

user_info.dropna(axis=0,inplace=True)
user_info = user_info.dropna(axis=0)

检查⽤户信息是否有重复

user_info.duplicated().sum()

gender字段的2为缺失值，　age_range 的0也为缺失值，在42W的⼤数据量下，可以删除缺失数据

user_info = user_info.loc[(user_info.gender != 2) & (user_info.age_range !=0),:]

age_range 中的8与7都代表是 >= 50 所以把8的更换7

user_info.age_range[user_info.age_range == 8] =7

电商–用户行为复购表

字段名	备注
user_id	买家ID
merchant_id	商家ID
label	包含{0, 1}，1表示重复买家，0表示⾮重复买家。

数据描述

user_merchant.user_id = user_merchant.user_id.astype("str")
user_merchant.merchant_id = user_merchant.merchant_id .astype("str")
user_merchant.label = user_merchant.label .astype("str")
user_merchant.describe(include="all")

整体数据为260864条，⽽label =0的⾼达 244912，1的仅占6%， 我们可以认为是不平衡数据，1的随只有6%但数据量达到15952，我们通过⽋采样的⽅式进⾏数据处理建模

#少类⼩于10%，我们就认为是不平衡数据了
from imblearn.under_sampling import NearMiss #KNN
ee =NearMiss(version=1)
#1. 选择离正样本平均距离最近的N个负样本
#2. 选择离正样本平均距离最远的N个负样本
#3. 两段式,先保留M个离正样本平均距离最近负样本,然后再从M个负样本中取平均距离最远的N个负样本取中间的
X_resampled, y_resampled = ee.fit_sample(user_merchant.loc[:,
["user_id","merchant_id"]], user_merchant.label)
user_merchant =pd.concat([X_resampled,y_resampled],axis=1)
user_merchant.head()

用户行为日志

字段名	备注
user_id	买家ID
item_id	商品ID
cat_id	商品类别
seller_id	商家ID
brand_id	商品品牌
time_stamp	时间
action_type	⽤户⾏为类别(0 表示点击， 1 表示加⼊购物⻋, 2 表示购买，3 表示收藏）

根据user_merchant的抽样结果，对user_log 表的数据进⾏初步筛选

user_log = user_log.loc[user_log.user_id.isin(user_merchant.user_id.values),:]
user_log =
user_log.loc[user_log.seller_id.isin(user_merchant.merchant_id.values),:]

user_log.user_id = user_log.user_id.astype("str")
user_log.item_id = user_log.item_id.astype("str")
user_log.cat_id = user_log.cat_id.astype("str")
user_log.seller_id = user_log.seller_id.astype("str")
user_log.brand_id = user_log.brand_id.astype("str")
user_log.time_stamp = user_log.time_stamp.astype("str")
user_log.action_type = user_log.action_type.astype("str")
user_log.describe(include="all")

user_log.apply(lambda x:[x.isnull().sum(),x.isnull().sum()/x.size], axis=0)

缺失⽐较少，我们可以补充众数或者删除

#过滤掉缺失数据
user_log = user_log[user_log.brand_id.isna()==False]

根据user_merchant的抽样结果，对user_info 表的数据进⾏初步筛选info

user_info =
user_info.loc[user_info.user_id.isin(user_merchant.user_id.unique()),:]

3.3 准备数据

1.数据预处理,2.特征提取,3.特征衍⽣

⽤户复购⾏为，考虑⽤户⾃身因素和商家因素，⼀般来说是商家提供的产品和服务能较好地满⾜⽤户需求；

所以我们通过⽤户、商铺、⽤户和商铺、⽐值等多个维度完成特征数据的提取

3.3.1 用户特征

• ⽤户交互总次数
• ⽤户各种⾏为总次数统计（点击、加购、收藏和购买）
• ⽤户交互了多少商铺数,多少种商品，多少商品类别和多少商品品牌数量
• ⽤户平均每天交互、购买的次数 ，⽤户平均每⽉交互、购买的次数

#⽤户交互总次数
user_feaut = user_log.groupby("user_id")["action_type"].count().to_frame()
#⽤户各种⾏为总次数统计（点击、加购、收藏和购买）
user_feaut_2 =
pd.pivot_table(user_log,index="user_id",columns="action_type",values="cat_id",a
ggfunc="count")
user_feaut = user_feaut.merge(user_feaut_2,on="user_id")
user_feaut.columns =["total_log","click","add_car","buy","collect"]
#⽤户交互了多少商铺数多少种商品，多少商品类别和多少商品品牌数量
user_feaut_2 = user_log.groupby("user_id")
["seller_id","item_id","cat_id","brand_id"].nunique()
user_feaut_2.columns = ["seller_count","item_count","cat_count","brand_count"]
user_feaut = user_feaut.merge(user_feaut_2,on="user_id")
#从时间戳中提⽉和⽇
user_log["month"] = user_log.time_stamp // 100;
user_log["day"] = user_log.time_stamp % 100;

# ⽤户平均每天交互、购买的次数 ，⽤户平均每⽉交互、购买的次数
user_feaut_2=user_log.groupby("user_id")["month","time_stamp"].nunique()
user_feaut_2.columns = ["month_count","day_count"]
user_feaut = user_feaut.merge(user_feaut_2,on="user_id")
user_feaut["month_avg_log"] = user_feaut.total_log/user_feaut.month_count
user_feaut["month_avg_buy"] =np.where(user_feaut.buy.isna(),0,user_feaut.buy/user_feaut.month_count)
user_feaut["day_avg_log"] = user_feaut.total_log/user_feaut.day_count
user_feaut["day_avg_buy"]
=np.where(user_feaut.buy.isna(),0,user_feaut.buy/user_feaut.day_count)
user_feaut.head()

3.3.2 商铺特征

• 商铺下所有交互总次数
• 商铺下各种⾏为总次数统计（点击、加购、收藏和购买）
• 商铺下交互的总⽤户数，多少被交互的商品，商品类别和商品品牌数量
• 商铺⽉平均有多少⽤户交互
• 商铺下交互的⽤户按年龄段和性别分别统计

#商铺下所有交互总次数
shop_feaut = user_log.groupby("seller_id")["user_id"].count().to_frame()
shop_feaut.columns=["total_count"]

#商铺下各种⾏为总次数统计（点击、加购、收藏和购买）
shop_feaut_2 =
pd.pivot_table(user_log,index="seller_id",columns="action_type",values="user_id
",aggfunc="count")
shop_feaut_2.columns = ["click","add_car","buy","collect"]
shop_feaut= shop_feaut.merge(shop_feaut_2,on="seller_id")

#商铺下交互的总⽤户数，多少被交互的商品，商品类别和商品品牌数量
shop_feaut_2 = user_log.groupby("seller_id")
["user_id","item_id","cat_id","brand_id"].nunique()
shop_feaut_2.columns=["user_count","item_count","cat_count","brand_count"]
shop_feaut= shop_feaut.merge(shop_feaut_2,on="seller_id")

#商铺⽉平均有多少⽤户交互
shop_feaut_2= user_log.groupby("seller_id")["month"].nunique()
shop_feaut= shop_feaut.merge(shop_feaut_2,on="seller_id")
shop_feaut["month_avg_user"]=shop_feaut.user_count/shop_feaut.month

#获取⽤户详细信息
user_log = user_log.merge(user_info,on="user_id")

#商铺下交互的⽤户按年龄段和性别分别统计
shop_feaut_2 =
pd.pivot_table(user_log,index="seller_id",columns="age_range",values="user_id",
aggfunc="nunique")
shop_feaut_2.columns=
["less18","between18and24","between25and29","between30and34","between35and39","
between40and49","grate50"]
shop_feaut= shop_feaut.merge(shop_feaut_2,on="seller_id")
shop_feaut_2 =
pd.pivot_table(user_log,index="seller_id",columns="gender",values="user_id",agg
func="nunique")
shop_feaut_2.columns=["gender_F","gender_M"]
shop_feaut= shop_feaut.merge(shop_feaut_2,on="seller_id")
shop_feaut.head()

#合并提取的特征到电商--⽤户⾏为复购表
user_feaut = user_feaut.reset_index()
user_merchant = user_merchant.merge(user_feaut,on="user_id",how="left")
shop_feaut = shop_feaut.reset_index()
user_merchant =
user_merchant.merge(shop_feaut,right_on="seller_id",left_on="merchant_id"
,how="left")

3.3.3 用户-商铺特征

• ⽤户在某商铺中交互的次数
• ⽤户在某商铺中各种⾏为次数（点击、加购、收藏和购买）
• ⽤户在商铺中⽉的平均交互次数
• ⽤户在商铺中⽉平均的各种⾏为次数（点击、加购、收藏和购买）
• ⽤户在商铺中第⼀次和最后⼀次交互的时间差
• ⽤户在商铺中交互有⼏个⽉
• ⽤户在商铺中交互有多少天
• ⽤户在商铺中交互的商品、商品类别和商品品牌的总个数

#⽤户在某商铺中交互的次数
user_shop_feaut = user_log.groupby(["seller_id","user_id"])["month"].count()
user_shop_feaut = user_shop_feaut.reset_index();
user_shop_feaut.columns= ["seller_id","user_id","us_total"]

#⽤户在某商铺中各种⾏为次数（点击、加购、收藏和购买）
user_shop_feaut_2 = pd.pivot_table(user_log,index=
["seller_id","user_id"],columns="action_type",values="day",aggfunc="count")
user_shop_feaut_2 = user_shop_feaut_2.reset_index()
user_shop_feaut_2.columns =
["seller_id","user_id","us_click","us_add_car","us_buy","us_collect"]
user_shop_feaut = user_shop_feaut.merge(user_shop_feaut_2,on=
["seller_id","user_id"])

#⽤户在商铺中⽉的平均交互次数 ,各种⾏为平均次数（点击、加购、收藏和购买）
user_shop_feaut_2 = user_log.groupby(["seller_id","user_id"])
["month"].nunique()
user_shop_feaut_2 = user_shop_feaut_2.reset_index()
user_shop_feaut_2.columns =["seller_id","user_id","us_month"]
user_shop_feaut = user_shop_feaut.merge(user_shop_feaut_2,on=
["seller_id","user_id"])
user_shop_feaut["us_month_avg_click"] =
user_shop_feaut.us_click/user_shop_feaut.us_month
user_shop_feaut["us_month_avg_addCar"]
=np.where(user_shop_feaut.us_add_car.isnull(),0,user_shop_feaut.us_add_car/user
_shop_feaut.us_month)
user_shop_feaut["us_month_avg_buy"]
=np.where(user_shop_feaut.us_buy.isnull(),0,user_shop_feaut.us_buy/user_shop_fe
aut.us_month)
user_shop_feaut["us_month_avg_collect"]
=np.where(user_shop_feaut.us_collect.isnull(),0,user_shop_feaut.us_collect/user
_shop_feaut.us_month)

#⽤户在商铺中第⼀次和最后⼀次交互的时间差
user_shop_feaut_2 = user_log.groupby(["seller_id","user_id"])
["time_stamp"].agg(["min","max"])
user_shop_feaut_2 = user_shop_feaut_2.reset_index()
user_shop_feaut_2.columns=["seller_id","user_id","us_min","us_max"]
user_shop_feaut_2["diff"] = user_shop_feaut_2.us_max-user_shop_feaut_2.us_min
user_shop_feaut_2 = user_shop_feaut_2.loc[:,["seller_id","user_id","diff"]]
user_shop_feaut = user_shop_feaut.merge(user_shop_feaut_2,on=
["seller_id","user_id"])

#⽤户在商铺中交互有多少天
user_shop_feaut_2 = user_log.groupby(["seller_id","user_id"])
["time_stamp"].nunique()
user_shop_feaut_2 = user_shop_feaut_2.reset_index();
user_shop_feaut_2.columns = ["seller_id","user_id","us_days"]
user_shop_feaut = user_shop_feaut.merge(user_shop_feaut_2,on=
["seller_id","user_id"])

#⽤户在商铺中交互的商品、商品类别和商品品牌的总个数
user_shop_feaut_2 = user_log.groupby(["seller_id","user_id"])
["item_id","cat_id",'brand_id'].nunique()
user_shop_feaut_2 = user_shop_feaut_2.reset_index()
user_shop_feaut_2.columns=
["seller_id","user_id","us_item_count","us_cat_count","us_brand_count"]
user_shop_feaut = user_shop_feaut.merge(user_shop_feaut_2,on=
["seller_id","user_id"])

user_shop_feaut.head()

合并⽤户-商铺特征（user_shop_feaut） 数据框到user_merchant 表内

user_merchant = user_merchant.merge(shop_feaut,right_on=
["seller_id","user_id"],left_on=["merchant_id","user_id"])
user_merchant.head()

3.3.4 比值特征

• ⽤户交互次数在所有⽤户交互总次数的占⽐
• ⽤户购买次数在所有⽤户购买总次数的占⽐
• 商铺交互次数在所有商铺交互总次数的占⽐
• 商铺购买次数在所有商铺购买总次数的占⽐
• 商铺中购买的⽤户数在所有商铺购买⽤户数的占⽐
• ⽤户在某商铺的交互次数在该⽤户所有交互次数的占⽐
• ⽤户在某商铺的购买次数在该⽤户所有购买次数的占⽐
• ⽤户在某商铺的交互次数在该商铺所有交互次数中的占⽐
• ⽤户在某商铺的购买次数在该商铺所有购买次数中的占⽐
• 商铺中回购（购买次数>1）的⽤户数占总回购⽤户数的⽐例
• 商铺中回购的总次数占商铺中⽤户总购买次数的⽐例
• 商铺中回购的商品类别总数在商铺中⽤户购买商品类别总数的占⽐
• ⽤户有回购的商铺数在该⽤户所有购买⾏为商铺数的占⽐
• ⽤户回购次数在该⽤户所有购买总次数的占⽐

#⽤户交互次数在所有⽤户交互总次数的占⽐
all_user_log = user_log.shape[0]
user_merchant["user_total_log_p"] = user_merchant.total_log/all_user_log
#⽤户购买次数在所有⽤户购买总次数的占⽐
all_user_log_buy = (user_log.action_type==2).sum()
user_merchant["user_total_buy_p"] = user_merchant.buy_x/all_user_log_buy

#商铺交互次数在所有商铺交互总次数的占⽐
all_user_log = user_log.shape[0]
user_merchant["shop_total_log_p"] = user_merchant.total_count/all_user_log
#商铺购买次数在所有商铺购买总次数的占⽐
all_user_log_buy = (user_log.action_type==2).sum()
user_merchant["shop_total_buy_p"] = user_merchant.buy_y/all_user_log_buy
#商铺中购买的⽤户数在所有商铺购买⽤户数的占⽐
all_buy_user_count =user_log.user_id[user_log.action_type==2].nunique()
user_merchant["shop_buyuser_totalbuyuser_p"] =
user_merchant.us_buy/all_buy_user_count

#⽤户在某商铺的交互次数在该⽤户所有交互次数的占⽐
user_merchant["us_log_p"] = user_merchant.us_total/user_merchant.total_log
#⽤户在某商铺的购买次数在该⽤户所有购买次数的占⽐
user_merchant["us_buy_p"] = user_merchant.us_buy/user_merchant.buy_x
#⽤户在某商铺的交互次数在该商铺所有交互次数中的占⽐
user_merchant["us_log_p"] = user_merchant.us_total/user_merchant.total_count
#⽤户在某商铺的购买次数在该商铺所有购买次数中的占⽐
user_merchant["us_log_p"] = user_merchant.us_buy/user_merchant.buy_y

#商铺中回购（购买次数>1）的⽤户数占总回购⽤户数的⽐例
#认为⼀天的为⼀个订单
#总回购⽤户数
temp = user_log.uid_day[user_log.action_type==2].unique()
buy_double_user = (pd.Series(map(lambda x:x.split("_")
[0],temp)).value_counts()>1).sum()

#定义函数获得指定店铺的回归⽤户数
def get_shop_double(shop_id):
	temp = user_log.uid_day[(user_log.action_type==2) & (user_log.seller_id == shop_id)].unique()
	buy_double_user = (pd.Series(map(lambda x:x.split("_")[0],temp)).value_counts()>1).sum()
	return [shop_id,buy_double_user]

#遍历每个店铺获得其回购⽤户数
temp = pd.DataFrame(map(get_shop_double,user_log.seller_id.unique()),columns= ["seller_id","double_user"])
temp.head()

user_merchant =
user_merchant.merge(temp,right_on="seller_id",left_on="merchant_id")
user_merchant.head()

#计算⽐值
user_merchant["shop_doubleU_totaldoubleU_p"] =
user_merchant.double_user/buy_double_user
user_merchant.head()

#商铺中回购的总次数占商铺中⽤户总购买次数的⽐例
#获得指定店铺的回购⽤户⽐
def get_shop_double_order(shop_id):
	temp = user_log.uid_day[(user_log.action_type==2) & (user_log.seller_id == shop_id)].unique()
	temp = pd.Series(map(lambda x:x.split("_")[0],temp)).value_counts()
	total_buy = temp.sum()
	double = (temp-1).sum()
	return [shop_id,double/total_buy]

#遍历每⼀个店铺，获得其商铺中回购的总次数占商铺中⽤户总购买次数的⽐例
temp = pd.DataFrame(map(get_shop_double_order,user_log.seller_id.unique()),columns= ["merchant_id","shop_Repurchase_P"])
temp.head()

user_merchant = user_merchant.merge(temp,on="merchant_id")
user_merchant.head()

#商铺中回购的商品类别总数在商铺中⽤户购买商品类别总数的占⽐
def get_shop_double_cat(shop_id):
	temp = user_log.cat_id[(user_log.action_type==2) & (user_log.seller_id == shop_id)].value_counts()
	zong = temp.sum()
	fugou = (temp-1).sum()
	return [shop_id,fugou/zong]

#遍历所有商铺，获得其品类回购率
temp
=pd.DataFrame(list(map(get_shop_double_cat,user_log.seller_id.unique())),column
s=["merchant_id","shop_Repurchase_cat_P"])
user_merchant = user_merchant.merge(temp,on="merchant_id")
user_merchant.head()

#⽤户有回购的商铺数在该⽤户所有购买⾏为商铺数的占⽐
def get_shop_double_us(user_id):
	temp = user_log.seller_id[(user_log.action_type==2) & (user_log.user_id == user_id)].value_counts()
	zong = temp.size
	fugou = (temp>1).sum()
	return [user_id,fugou/zong]

#遍历所有⽤户 ，获得其有回购的商铺数在该⽤户所有购买⾏为商铺数的占⽐
temp
=pd.DataFrame(list(map(get_shop_double_us,user_log.user_id.unique())),columns=
["user_id","User_RepurchaseShop_P"])
user_merchant = user_merchant.merge(temp,on="user_id")
user_merchant.head()

#⽤户回购次数在该⽤户所有购买总次数的占⽐
def get_User_Repurchase(user_id):
	temp = user_log.uid_day[(user_log.action_type==2) & (user_log.user_id == user_id)].unique()
	temp = pd.Series(map(lambda x:x.split("_")[0],temp)).value_counts()
	total_buy = temp.sum()
	double = (temp-1).sum()
	return [user_id,double/total_buy]

#遍历所有⽤户 ，获得其回购次数在该⽤户所有购买总次数的占⽐
temp
=pd.DataFrame(list(map(get_User_Repurchase,user_log.user_id.unique())),columns=
["user_id","User_Repurchase_P"])
user_merchant = user_merchant.merge(temp,on="user_id")
user_merchant.head()

3.3.5 缺失值填充

由于都是计算字段，所以缺失可以补充为0

user_merchant.fillna(0)

删除不必要的列

user_merchant =
user_merchant.drop(["seller_id_x","seller_id_y","user_id","merchant_id"],axis=1
)
user_merchant.columns

3.3.6 最终维度数据

字段名	备注
label	是否复购
total_log	⽤户交互总次数
click_x	⽤户点击总次数
add_car_x	⽤户加购总次数
buy_x	⽤户购买总次数
collect_x	⽤户收藏总次数
seller_count	⽤户交互商铺数
item_count_x	⽤户交互商品数
cat_count_x	⽤户交互商品类别数
brand_count_x	⽤户交互商品品牌数
month_count	⽤户交互⽉数
day_count	⽤户交互天数
month_avg_log_x	⽤户每⽉平均交互数
month_avg_buy	⽤户每⽉平均购买数
day_avg_log	⽤户每天平均交互数
day_avg_buy	⽤户每天平均购买数
total_count	商铺下所有交互总次数
click_y	商铺下点击总次数
add_car_y	商铺下加购总次数
buy_y	商铺下购买总次数
collect_y	商铺收藏买总次数
user_count	商铺下交互的总⽤户数
item_count_y	商铺下交互的总商品数
cat_count_y	商铺下交互的总商品类别数
brand_count_y	商铺下交互的总商品品牌数
month	商铺下交互的⽉数
month_avg_user	商铺下⽉平均交互⽤户数
less18	商铺下交互的⽤户年龄段为<18的⽤户数
between18and24	商铺下交互的⽤户年龄段为【18，24】的⽤户数
between25and29	商铺下交互的⽤户年龄段为【25，29】的⽤户数
between30and34	商铺下交互的⽤户年龄段为【30，34】的⽤户数
between35and39	商铺下交互的⽤户年龄段为【35，39】的⽤户数
between40and49	商铺下交互的⽤户年龄段为【40，49】的⽤户数
grate50	商铺下交互的⽤户年龄段为>50的⽤户数
gender_M	商铺下交互的⽤户性别为男的⽤户数
gender_F	商铺下交互的⽤户性别为⼥的⽤户数
us_total	⽤户在某商铺中交互的次数
us_click	⽤户在某商铺中点击的次数
us_add_car	⽤户在某商铺中加购的次数
us_buy	⽤户在某商铺中购买的次数
us_collect	⽤户在某商铺中收藏的次数
us_month	⽤户在商铺交互⽉数
us_month_avg_total	⽤户在商铺中⽉平均交互的次数
us_month_avg_click	⽤户在商铺中⽉平均点击的次数
us_month_avg_addCar	⽤户在商铺中⽉平均加购的次数
us_month_avg_buy	⽤户在商铺中⽉平均购买的次数
us_month_avg_collect	⽤户在商铺中⽉平均收藏的次数
diff	⽤户在商铺中第⼀次和最后⼀次交互的时间差
us_days	⽤户在商铺中交互的天数
us_item_count	⽤户在商铺中交互的商品数
us_cat_count	⽤户在商铺中交互的商品类别数
us_brand_count	⽤户在商铺中交互的商品品牌数
user_total_log_p	⽤户交互次数在所有⽤户交互总次数的占⽐
user_total_buy_p	⽤户购买次数在所有⽤户购买总次数的占
shop_total_log_p	商铺交互次数在所有商铺交互总次数的占⽐
shop_total_buy_p	商铺购买次数在所有商铺购买总次数的占⽐
Shop_buy_users	商铺中发⽣购买⾏为的⽤户数
shop_buyuser_totalbuyuser_p	商铺中购买的⽤户数在所有商铺购买⽤户数的占⽐
us_user_log_p	⽤户在某商铺的交互次数在该⽤户所有交互次数的占⽐
us_user_buy_p	⽤户在某商铺的购买次数在该⽤户所有购买次数的占⽐
us_shop_log_p	⽤户在某商铺的交互次数在该商铺所有交互次数中的占⽐
us_shop_buy_p	⽤户在某商铺的交互次数在该商铺所有交互次数中的占⽐
double_user	店铺复购⽤户数
shop_doubleU_totaldoubleU_p	商铺中回购的⽤户数占总回购购买⽤户数的⽐例
shop_Repurchase_P	商铺中回购的总次数占商铺中⽤户总购买次数的⽐例
shop_Repurchase_cat_P	商铺中回购的商品类别总数在商铺中⽤户购买商品类别总数的占⽐
User_RepurchaseShop_P	⽤户有回购的商铺数在该⽤户所有购买⾏为商铺数的占⽐
User_Repurchase_P	⽤户回购次数在该⽤户所有购买总次数的占⽐

3.4 生成模型 & 模型调优

import os
import time
# 模型处理模块
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
# 标准化处理模块
from sklearn.preprocessing import StandardScaler
# 常规模型
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
# 集成学习和stacking模型
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier,
RandomForestClassifier
import xgboost as xgb
from xgboost.sklearn import XGBClassifier
from mlxtend.classifier import StackingClassifier
# 评价标准模块
from sklearn import metrics
from sklearn.metrics import
accuracy_score,roc_auc_score,recall_score,precision_score
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline

#拆分训练集，测试集合
X_train,X_test,y_train,y_test =
train_test_split(user_merchant.iloc[:,3:],user_merchant.iloc[:,2],test_size=0.3
,random_state=6)

# 封装模型调⽤ 评估函数
def train_model(X_train, y_train, X_test, y_test,
				model,model_name):
	print('训练{}'.format(model_name))
	
	clf=model
	start = time.time()
	clf.fit(X_train, y_train.values.ravel())
	
	#验证模型
	print('训练准确率：{:.4f}'.format(clf.score(X_train, y_train)))
	
	predict=clf.predict(X_test)
	score = clf.score(X_test, y_test)
	precision=precision_score(y_test,predict)
	recall=recall_score(y_test,predict)
	print('测试准确率：{:.4f}'.format(score))
	print('测试精确率：{:.4f}'.format(precision))
	print('测试召回率：{:.4f}'.format(recall))
	
	end = time.time()
	duration = end - start
	print('模型训练耗时：{:6f}s'.format(duration))
	
	return clf, score,precision,recall, duration

#从模型中备选模型中选择⼀个最有模型
model_name_param_dict = { 'LR': (LogisticRegression(penalty ="L2")),
						'DT':
(DecisionTreeClassifier(max_depth=10,min_samples_split=10)),
						'AdaBoost': (AdaBoostClassifier()),
						'GBDT': (GradientBoostingClassifier()),
						'RF': (RandomForestClassifier()),
						'XGBoost':(XGBClassifier())
						}
						
result_df = pd.DataFrame(columns=['Accuracy
(%)','precision(%)','recall(%)','Time (s)','model'],
								index=list(model_name_param_dict.keys()))
								
for model_name, model in model_name_param_dict.items():
	clf, acc,pre,recall, mean_duration = train_model(X_train, y_train,
													X_test, y_test,
													model,model_name)
													
	model_dict
	result_df.loc[model_name, 'Accuracy (%)'] = acc
	result_df.loc[model_name, 'precision(%)'] = pre
	result_df.loc[model_name, 'recall(%)'] = recall
	result_df.loc[model_name, 'Time (s)'] = mean_duration
	result_df.loc[model_name, 'model'] = clf
	
result_df.to_csv(os.path.join('model_comparison.csv'))

#随机森林⽹格搜索参数调优
param_grid = {'n_estimators': [20, 50, 100,300], 'max_features':
[10,20,30,40,50,60],"max_depth":[4,6,8,10,12],
					"min_samples_split": [10,20,30,40],"min_samples_leaf":
[5,10,20,30]},
model = RandomForestClassifier()
grid_search = GridSearchCV(model, param_grid, cv=5, scoring='roc_auc')
result = grid_search.fit(X_train, y_train)
result.best_params_

#参数调优后模型质量预测
pre = result.predict(X_test)
#训练集 roc_auc, 测试集精准率 ，召回率
print(result.best_score_,precision_score(y_test,pre),recall_score(y_test,pre))

#XGBoost 参数调优
param_grid = {'n_estimators': [20, 50, 100,300],"max_depth":[4,6,8,10,12],
			"subsample": [0.3,0.5,0.6,0.7,0.8],"colsample_bytree":
[0.3,0.5,0.6,0.7,0.8]},
model = XGBClassifier()
grid_search = GridSearchCV(model, param_grid, cv=3, scoring='roc_auc')
temp=grid_search.fit(X_train, y_train)
temp.best_params_

pre = temp.predict(X_test)
#测试集精准率和召回率
print(precision_score(y_test,pre),recall_score(y_test,pre))

#对选择好的模型进⾏保存，以便后期使⽤
from sklearn.externals import joblib
#保存模型
joblib.dump(temp,'model.model')
#加载模型
#clf=joblib.load('model.model')

3.5 部署投入生产