分享参赛方案及答辩ppt，欢迎大家交流

Github地址：https://github.com/Smilexuhc/Xingwangbankcup-top3

baseline作者：XBuder

作者公众号：麻婆豆腐AI

思路：

统计车辆在星期1-7天最常去哪些地点，对这些地点做标记，之后去过为1，否则为0，以此做标签，把概率最高的地点推荐给选手

使用模型：

逻辑回归

优化方法：

1.继续细化统计车辆在1-7天的哪个小时去过哪些地点（如统计距0点的分钟数或者小时数），即按小时做推荐。另外还可以针对是否为节假日做标记构建特征。

2.挖掘同时间，同地域的车辆是否有相似性，对节假日的推荐单独处理。

3.尝试使用svm，xgb,lgb等模型，并进行参数调整

4.模型融合

导入所需要的包，忽略警告

import pandas as pd

import numpy as np

import warnings

warnings.filterwarnings('ignore')

评分算法

from math import radians, atan, tan, sin, acos, cos

def getDistance(latA, lonA, latB, lonB):

    ra = 6378140  # 赤道半径: 米

    rb = 6356755  # 极线半径: 米

    flatten = (ra - rb) / ra  # Partial rate of the earth

    # change angle to radians

    radLatA = radians(latA)#弧度

    radLonA = radians(lonA)

    radLatB = radians(latB)

    radLonB = radians(lonB)



    try:

        pA = atan(rb / ra * tan(radLatA))

        pB = atan(rb / ra * tan(radLatB))

        x = acos(sin(pA) * sin(pB) + cos(pA) * cos(pB) * cos(radLonA - radLonB))

        c1 = (sin(x) - x) * (sin(pA) + sin(pB)) ** 2 / cos(x / 2) ** 2

        c2 = (sin(x) + x) * (sin(pA) - sin(pB)) ** 2 / sin(x / 2) ** 2

        dr = flatten / 8 * (c1 - c2)

        distance = ra * (x + dr)

        return distance  # meter

    except:
        return 0.0000001
def f(d):

    return 1 / (1 + np.exp(-(d-1000)/250))

计算误差值

def getDistanceFromDF(data):

    tmp = data[['end_lat','end_lon','predict_end_lat','predict_end_lon']].astype(float)
    #从数据中取出'end_lat','end_lon','predict_end_lat','predict_end_lon'4列，转为浮点型

    error = []#设置一个空列表error

    for i in tmp.values:

        t = getDistance(i[0],i[1],i[2],i[3])#逐条计算误差

        error.append(t)#将误差加入列表error

    print (np.sum(f(np.array(error))) / tmp.shape[0])#打印

转化数据集中的日期为pandas中的datatime类型

这里生成了2个新的特征，出发的星期和出发的小时，实际我们没有使用小时这个特征，同学们可以尝试用一下

def dateConvert(data,isTrain):

    print ('convert string to datetime')

    data['start_time'] = pd.to_datetime(data['start_time'])#转化开始时间

    if isTrain:#如果是训练集

        data['end_time'] = pd.to_datetime(data['end_time'])#转化结束时间

    data['weekday'] = data['start_time'].dt.weekday + 1#生成新的一列，为星期几，weekday对应0到6，所以这里加1
    data['hour']= data['start_time'].dt.hour
    return data

合并经纬度

注意：更常用的处理方法为将经纬度转化为geohash编码，这里只是做了精度和合并处理

def latitude_longitude_to_go(data,isTrain):

    tmp = data[['start_lat','start_lon']]#取出出发地经纬度

    start_geohash = []#定义一个空列表

    for t in tmp.values:#逐行遍历出发地经纬度

        start_geohash.append(str(round(t[0],5)) + '_' + str(round(t[1],5)))#保留小数点后5位，将经纬度合并

    data['startGo'] = start_geohash#生成新的一列，值为合并后的经纬度

    if isTrain:#如果是训练集，对目的地经纬度做如上处理

        tmp = data[['end_lat','end_lon']]

        end_geohash = []

        for t in tmp.values:

            end_geohash.append(str(round(t[0],5))+ '_' + str(round(t[1],5)))

        data['endGo'] = end_geohash#生成新的一列，值为合并后目的地经纬度

    return data

统计用户去过最多的7个地方

def getMostTimesCandidate(candidate):
    
    #取9月前的数据
    mostTimeCandidate = candidate[candidate['start_time']<='2018-08-30 23:59:59']
    #取'out_id','endGo','end_lat','end_lon','weekday'列
    mostTimeCandidate = mostTimeCandidate[['out_id','endGo','end_lat','end_lon','weekday']]
    #按车辆id、目的地、星期分组（agg）统计目的地出现的次数,放入生成的mostCandidateCount列
    mostTimeCandidate_7 = mostTimeCandidate.groupby(['out_id','endGo','weekday'],as_index=False)['endGo'].agg({'mostCandidateCount':'count'})
    #按出现次数和车辆id降序排列
    mostTimeCandidate_7.sort_values(['mostCandidateCount','out_id'],inplace=True,ascending=False)
    #按车辆id和星期分组，取去的最多的7条数据
    mostTimeCandidate_7 = mostTimeCandidate_7.groupby(['out_id','weekday']).head(7)

    return mostTimeCandidate_7

将合并后的经纬度拆分

def geoHashToLatLoc(data):
    #取出目的地
    tmp = data[['endGo']]
    #设置空列表，预测的目的地纬度
    predict_end_lat = []
    #设置空列表，预测的目的地经度
    predict_end_lon = []
    #逐行遍历
    for i in tmp.values:
        #取出每行的经纬度，放入列表
        lats, lons = str(i[0]).split('_')

        predict_end_lat.append(lats)

        predict_end_lon.append(lons)
    #生成新的列
    data['predict_end_lat'] = predict_end_lat

    data['predict_end_lon'] = predict_end_lon

    return data

计算两地点的距离

def calcGeoHasBetween(go1,go2):

    latA, lonA = str(go1).split('_')

    latB, lonB = str(go2).split('_')

    distence = getDistance(float(latA), float(lonA), float(latB), float(lonB))

    return distence

对整个数据集计算距离

def calcGeoHasBetweenMain(data):

    distance = []

    tmp = data[['endGo','startGo']]

    for i in tmp.values:

        distance.append(calcGeoHasBetween(i[0],i[1]) / 1000 )

    data['distance'] = distance

    return data

读取数据&特征工程

读取训练集

用1-6月去提取最常去的地方 用7月去训练

print ('begin')
train = pd.read_csv('train_new.csv',low_memory=False)#读取数据集，注意声明low_memory=False，否则会类型错误
print (train['start_time'].min(),train['start_time'].max())#打印训练集出发的最早时间和最晚时间
print (train[train['start_time']>'2018-06-30 23:59:59'].shape)#打印训练集出发时间在6月30日之后的数据的维度
print (train[train['start_time']<='2018-06-30 23:59:59'].shape)#打印训练集出发时间在6月30日及之前的数据的维度

begin

2018-01-01 00:01:58 2018-08-01 00:49:30

(205111, 8)

(1290703, 8)

test = pd.read_csv('test_new.csv',low_memory=False)#读取测试集
print (test['start_time'].min(),test['start_time'].max())
print (test.shape)

2018-09-01 00:32:42 2018-10-23 23:59:48

(58097, 5)

trainIndex = train.shape[0]#设置训练集索引
testIndex = test.shape[0]#设置测试集索引
print (trainIndex,testIndex)

1495814 58097

时间转化

train = dateConvert(train,True)
test = dateConvert(test,False)

convert string to datetime

convert string to datetime

合并经纬度

train = latitude_longitude_to_go(train,True)
test = latitude_longitude_to_go(test,False)

生成特征工程完成后的文件

train.to_csv('train1.csv',index=False)
test.to_csv('test1.csv',index=False)

userMostTimes3loc = getMostTimesCandidate(train)

val = train[train['start_time']>'2018-06-30 23:59:59']#取6月30日后数据做验证
#取出'r_key','out_id','end_lat','end_lon','weekday','startGo','endGo','start_lat','start_lon'列
val = val[['r_key','out_id','end_lat','end_lon','weekday','startGo','endGo','start_lat','start_lon']]
#将'endGo'重命名为'trueEndGo'
val.rename(columns={'endGo':'trueEndGo'},inplace=True)
#以'out_id','weekday'为关键字，对左表取交集，合并val和userMostTimes3loc表
val = pd.merge(val,userMostTimes3loc,on=['out_id','weekday'],how='left',copy=False)
#将val['endGo']中的目的地缺失值填充为起始地点
val['endGo'] = val['endGo'].fillna(val['startGo'])
#判断是否真的去了推荐的地点，如果去了为Ture，否则为False
val['flag1'] = val['trueEndGo'] == val['endGo']
#将True转化为1，False转化为0
val['flag1'] = val['flag1'].astype(int)
#计算距离
val = calcGeoHasBetweenMain(val)

#取出'r_key','out_id','weekday','startGo','start_lat','start_lon'列作为测试集
test = test[['r_key','out_id','weekday','startGo','start_lat','start_lon']]
#以'out_id','weekday'为关键字，对左表取交集，合并test和userMostTimes3loc表
test = pd.merge(test,userMostTimes3loc,on=['out_id','weekday'],how='left',copy=False)
#将测试集endGo列填充为出发地点
test['endGo'] = test['endGo'].fillna(test['startGo'])
#计算距离
test = calcGeoHasBetweenMain(test)

使用模型进行预测

这里使用了逻辑回归模型 同学们可以使用xgb，lgb等模型，相信会取得更好的成绩

feature = ['start_lat','start_lon','weekday','distance','mostCandidateCount']
#这里可以导入其它算法如svm,xgb,lgb等
from sklearn.linear_model import LogisticRegression

print ('training')

model= LogisticRegression()#使用逻辑回归模型训练,修改这里为sklearn中的其它模型

model.fit(val[feature].fillna(-1).values,val['flag1'].values)#x为fearture，将空值填充为-1，y值为val['flag1']，即是否推荐成功

pre = model.predict_proba(val[feature].fillna(-1).values)[:,1]#在验证集预测结果，为概率值

training

val_result = val[['r_key','endGo','end_lat','end_lon',]]
val_result['predict'] = pre

val_result = val_result.sort_values(['predict'],ascending=False)#按预测概率降序排列
val_result = val_result.drop_duplicates(['r_key'])#按r_key字段去重

val = geoHashToLatLoc(val)#将预测的结果切片为维度和经度
getDistanceFromDF(val)#计算在验证集上预测的得分

0.7703523722443778

subPre = model.predict_proba(test[feature].fillna(-1).values)[:,1]#在测试集上预测

test_result = test[['r_key','endGo']]#取出预测结果
test_result['predict'] = subPre#生成概率列

#按预测概率降序排列
test_result = test_result.sort_values(['predict'],ascending=False)
#按r_key字段去重
test_result = test_result.drop_duplicates(['r_key'])
#将预测的结果切片为维度和经度
test_result = geoHashToLatLoc(test_result)

#生成提交结果
submit = test_result[['r_key','predict_end_lat','predict_end_lon']]
submit.columns = ['r_key','end_lat','end_lon']
submit.to_csv('result.csv',index=False)

基本框架是KEA算法，也就是将关键词提取转化为二分类问题。

举个栗子：

核心部分的特征提取代码如下：

# 产生特征的函数
def gen_feature(id, text):
    # 读取分词结果
   a,b=cut(text)

    # 清洗分词结果
    title_words = clean(a)
    context_words = clean(b)

    # 读取词性标注结果
    postag = dict(cuter5ed.find_one({'id': id})['postag'])
    c = cuter6ed.find_one({'id': id}, )['pos']

    # 计数
    tf_title = Counter(title_words)
    tf_context = Counter(context_words)

    # 计算总词数
    freq = tf_title + tf_context
    total = sum(freq.values())  # 总词数

    # 计算tfidf并排序
    tfidf = {}
    for k in freq:
        tfidf[k] = freq[k] * idf_freq.get(k, median_idf) / total
    tfidf_tuple = sorted(tfidf, key=tfidf.__getitem__, reverse=True)

    # 筛选候选词
    candidates = set([j for j in tfidf_tuple[:num_of_word_extract]] + title_words)

    # 开始提取特征，此处用dict不用pandas.DataFrame是出于效率考虑
    rrl = {}
    for w in candidates:
        s = dict()
        pos_ = postag.get(w, 'REST')
        newpos = pos_[0]

        s['tfidf'] = tfidf[w]  # tfidf系数
        s['tf_title'] = tf_title[w]  # 标题中词频
        s['tf_context'] = tf_context[w]  # 内容中词频
        s['rank'] = tfidf_tuple.index(w)  # tfidf系数排名
        s['pos'] = pos_  # jieba分词给出的词性
        s['new_pos'] = newpos if newpos in ['n', 'v', 'x', 'R'] else 'H'  # 对jieba分词结果进行处理
        s['hanlp_pos'] = search_pos(w, c)  # hanlp的词性标注
        s['title_position'] = text['title'].find(w)  # 首次出现位置
        s['title_position_r'] = len(text['title']) - text['title'].rfind(w)  # 最后一次出现位置（倒着数）
        s['title_position_rr'] = text['title'].rfind(w)  # 最后一次出现位置（正着数）
        s['position'] = text['context'].find(w)  # 首次出现位置
        s['position_r'] = len(text['context']) - text['context'].rfind(w)  # 最后一次出现位置（倒着数）
        s['position_rr'] = text['context'].rfind(w)  # 最后一次出现位置（正着数）
        s['length'] = len(w)  # 词汇长度
        s['idf'] = idf_freq.get(w, median_idf)  # idf逆序数
        # s['local_idf']=local_idf.get(w,10.2063)
        s['train_freq'] = ck.get(w, 1) - 1  # Relu一下，避免过拟合。
        s['in_title'] = 1 if w in title_words else 0  # 是否在title中

        rrl[w] = s

    r = pd.DataFrame.from_dict(rrl, orient='index')

    r['tf_title_gm'] = r['tf_title'].mean()  # 组均值
    r['idf_gm'] = r['idf'].mean()  # 组均值
    r['doclen'] = len(text.context)  # 文本总长度
    r['tf_title_rk'] = r['tf_title'].rank()  # tf排序
    r['idf_rk'] = r['idf'].rank()  # idf排序

    r['id'] = id  # 文档编号
    r['wid'] = r.index.map(lambda j: j + id)  # 词与文档编号拼接，作为unique的index
    r.reset_index(inplace=True, drop=False)
    r.set_index('wid', inplace=True)
    r.rename({'index': 'word'}, axis=1, inplace=True)

    return r

在按照上述步骤，对候选词逐个处理之后，再进行统一处理如下（出于速度考虑）：

# 处理特征
def handle_features(this_set):
    # 加载word2vec模型，进行词汇向量化嵌入
    model_w2v = Word2Vec.load('../pickles/model_w2v')
    wv_name = ['w2vec_{}'.format(k) for k in range(20)]

    words = [k for k in set(this_set.word) if k in model_w2v]
    w2v_dict = dict(zip(words, model_w2v.wv[words]))
    w2v = pd.DataFrame.from_dict(w2v_dict, 'index')
    w2v.columns = wv_name
    this_set = this_set.join(w2v, on='word').fillna(0)
    del model_w2v, w2v
    gc.collect()

    # 加载doc2vec模型，进行文档向量化嵌入
    dv_name = ['d2vec_{}'.format(k) for k in range(20)]
    model_d2v = Doc2Vec.load('../pickles/model_d2v')
    ids = set(this_set.id)
    d2v_dict = dict(zip(ids, [model_d2v.docvecs[j] for j in ids]))
    dv = pd.DataFrame.from_dict(d2v_dict, 'index')
    dv.columns = dv_name
    this_set = this_set.join(dv, on='id')
    del model_d2v, dv
    gc.collect()

    # 计算余弦距离
    this_set['cos_distance'] = cal_cosd(this_set)

    # 处理成pandas.Categorical格式，便于分类器识别
    this_set.pos = pd.Categorical(this_set.pos)
    this_set.new_pos = pd.Categorical(this_set.new_pos)
    this_set.hanlp_pos = pd.Categorical(this_set.hanlp_pos)

    # 是否在自定义词典中
    this_set['is_book'] = this_set.word.str.upper().apply(lambda k: k in bid)
    this_set['is_txkw'] = this_set.word.str.upper().apply((lambda k: k in a4))
    this_set['is_txkw2'] = this_set.word.str.upper().apply(lambda k: k in a3)

    # 词中是否包含数字、英文字母
    letter = re.compile('[A-Za-z]')
    digit = re.compile('[0-9]')
    this_set['have_letter'] = this_set.word.map(lambda w: bool(letter.search(w)))
    this_set['have_digit'] = this_set.word.map(lambda w: bool(digit.search(w)))

    return this_set

矩阵化计算余弦相似度的函数如下：

# 用矩阵计算的方法，一次性计算一组词的cosine距离
def cosgroup(g):
    x = g.values
    i = x.sum(1) != 0
    z = np.zeros(i.shape)
    x = x[i, :]
    y = x.T
    u = np.dot(x, y)
    u1 = np.sqrt(np.sum(np.multiply(x, x), 1))
    u1 = np.dot(u1.reshape([-1, 1]), np.ones([1, x.shape[0]]))
    u2 = u1.T
    r = u / np.multiply(u1, u2)
    z[i] = r.mean(1)
    return z


# 计算cos距离
def cal_cosd(s):
    t = s[['w2vec_{}'.format(k) for k in range(20)]].groupby(s.id)
    res = []
    for tp, g in t:
        res.append(cosgroup(g))
    return np.hstack(res)

BTW：MacBook的OS X系统好难用！

现将本队伍参赛的解决方案和代码，分享给大家，一起学习交流。才疏学浅，还望多多指教。

当时二等奖先报我们队伍名字，还以为第4呢，原来是第2。不过也没差别啦.....详情请戳下面的链接

竞赛总结与分享

有谁能解释一下评价函数吗？装机容量也没有告诉我们

建了个讨论群，互相讨论

大佬们都是用的什么方法

开源是一种文化，一种精神，分享对于时代创新与进步有着重要意义，一直以来，DC都在鼓励参赛者们发扬开源精神，在分享中相互学习。

本次半程彩蛋来自---阮耀灿，这是史上最详尽的一次分享，从数据处理到基本思路到解决策略都一一展示，希望大家能从中得到些启发，我们也期待更多参赛者来分享开源！

祝您玩儿的愉快～

备注：

分析工具：anaconda上写python，画图用到pyecharts，所以后续的内容都是先一块代码，再一块图或者文字描述。

一、熟悉数据

不急着上模型，调参数，先熟悉下数据:

 1. 这是一个手机游戏的客户数据，注册个账号玩了一下。

 2.有什么类型的feature：user_id、注册时间、游戏资源（木头、石头、象牙、肉、魔法等）、兵种（勇士、驯兽师、萨满）、加速券（通用、建筑、科研、训练、治疗）、建筑、科研、PVP（玩家对战）、PVE（人机对战）、在线时长、付费金额、付费次数。这些都 是注册前7天的信息  

 3. label：前45天的付费金额.

再问几个问题：

1.user_id在train和test中有没重复？

2.数据在时间上的分布？

3.有多少付费玩家，会给多少钱，分布如何？比例随时间的变化？

4.在线时长如何？

5.单次付费有什么额度的？

1、user_id在train和test中有没重复？

# 读取数据
data = pd.read_csv("tap_fun_train.csv", parse_dates=True)
data_test = pd.read_csv("tap_fun_test.csv", parse_dates=True)

# 提取user_id列，并做合并处理
data_id = pd.DataFrame(data['user_id'],columns=['user_id'])
data_test_id = pd.DataFrame(data_test['user_id'],columns=['user_id'])
pd.merge(data_id, data_test_id, on = 'user_id')

没有重复的user_id，就是检查下，不要多想，哈哈！

2、 玩家注册时间分布

# 增加两列
data['register_time_month'] = data.register_time.str[:7]
data['register_time_day'] = data.register_time.str[6:10]

# 统计并保存为dataframe
data_month_df = pd.DataFrame(data['register_time_month'].value_counts()).sort_index()
# print(data_month_df)
data_day_df = pd.DataFrame(data['register_time_day'].value_counts()).sort_index()
# print(data_day_df)

# 画图  用了echarts的python版，挺好用的，也美观
from pyecharts import Line, Grid

line1 = Line("玩家数量统计-月")
line1.add("玩家数量", data_month_df.index, data_month_df['register_time_month'], mark_line=["average"], mark_point=["max", "min"])

line2 = Line("玩家数量统计-日",title_top="50%")
line2.add("玩家数量", data_day_df.index, data_day_df['register_time_day'], mark_line=["average"], mark_point=["max", "min"])

grid = Grid(width = 1000, height = 1000)
grid.add(line1, grid_bottom="60%")
grid.add(line2, grid_top="60%")
grid.render()

grid

月数据：不完整的，1月是从26号开始的数据，3月只有到6号的数据。

日数据：平均每天注册人数有5.7万人，挺多的啊。其中2月19号有11.7万人注册，是平时的两倍，20号还有9.3万人注册，有推广活动吗？但是整体趋势上，注册用户是下降的。

3、 有多少付费玩家，比例随时间的变化，会给多少钱，分布如何？

     》有多少付费玩家？

data_pay_7 = copy.copy(data[data['pay_price']>0])
print(data_pay_7.shape)   # (41439, 111)
print(data_pay_7.shape[0]/data.shape[0])  # 0.018111395638212645

七天内付费的玩家有41439个，占比大概是1.811%。

   》付费玩家比例随时间的变化

# ----------------------------- 统计，改列明（避免冲突），合并，计算比例
data_pay_7_day_df = pd.DataFrame(data_pay_7['register_time_day'].value_counts()).sort_index()
# print(data_pay_7_day_df)
data_pay_7_day_df.rename(columns={'register_time_day':'pay_register_time_day'}, inplace = True)
data_day_count = pd.concat([data_pay_7_day_df, data_day_df], axis=1)
# print(data_day_count)
data_day_count['pay_percent'] = data_day_count['pay_register_time_day']/data_day_count['register_time_day']
# print(data_day_count)

# ----------------------------- 画图
from pyecharts import Overlap

line3 = Line()
line3.add("注册玩家数量", data_day_count.index, data_day_count['register_time_day'], mark_line=["average"], mark_point=["max", "min"])

line4 = Line()
line4.add("7天内付费玩家数量", data_day_count.index, data_day_count['pay_register_time_day'], mark_line=["average"], 
          mark_point=["max", "min"], yaxis_max=3000)

overlap = Overlap()
# 默认不新增 x y 轴，并且 x y 轴的索引都为 0
overlap.add(line3)
# 新增一个 y 轴，此时 y 轴的数量为 2，第二个 y 轴的索引为 1（索引从 0 开始），所以设置 yaxis_index = 1
# 由于使用的是同一个 x 轴，所以 x 轴部分不用做出改变
overlap.add(line4, yaxis_index=1, is_add_yaxis=True)
overlap.render()

overlap

from pyecharts import Bar, Overlap

line3 = Line()
line3.add("注册玩家数量", data_day_count.index, data_day_count['register_time_day'], mark_line=["average"], mark_point=["max", "min"])

bar = Bar()
bar.add("7天内付费玩家比例", data_day_count.index, data_day_count['pay_percent'], yaxis_max=0.1)


overlap = Overlap()
# 默认不新增 x y 轴，并且 x y 轴的索引都为 0
overlap.add(line3)
# 新增一个 y 轴，此时 y 轴的数量为 2，第二个 y 轴的索引为 1（索引从 0 开始），所以设置 yaxis_index = 1
# 由于使用的是同一个 x 轴，所以 x 轴部分不用做出改变
overlap.add(bar, yaxis_index=1, is_add_yaxis=True)
overlap.render()

overlap

注册用户的7天付费占比平均值是1.811%，分拆到每天的注册用户中，有起伏，但是波动不算大。

反而是某天（2月1、7、8、15、19、20号等）的注册用户越多，成功转化付费的好像不会“水涨船高”，也就是付费的还是那么多，促销回来的客户还是不付费？

   》会给多少钱？

data_pay_45 = copy.copy(data[data['prediction_pay_price']!=0])
print(data_pay_45['prediction_pay_price'].describe())
print('前45天合共付费：',data_pay_45['prediction_pay_price'].sum())

(上图)有4.6万客户前45天付款了，合计给了410万，最土豪的花了3.3万，土豪你不懂。

data_pay_7 = copy.copy(data[data['pay_price']!=0])
print(data_pay_7['pay_price'].describe())
print('前7天合共付费：',data_pay_7['pay_price'].sum())  
print('前45天合共付费：',data_pay_7['prediction_pay_price'].sum())

(上图)有4.14万客户前7天就有付款行为了，占了4.6万的90.1%（有9.9%前七天没给钱，后来给了）；

前七天合计花了122万，前45天花了391.7万，占4.6万客户前45天总付款410万的95.5%。

data_nopay_7_pay_45 = copy.copy(data_pay_45[data_pay_45['pay_price']==0])
print(data_nopay_7_pay_45['prediction_pay_price'].describe())
print('前七天没有，后45天有付款的合共付费：',data_nopay_7_pay_45['prediction_pay_price'].sum())

(上图)有4549个客户前7天没付款，但是前45天付款的，占了9.9%，金额18.6万，占比4.53%。

data_pay_7_nopay_45 = copy.copy(data_pay_7[data_pay_7['pay_price']==data_pay_7['prediction_pay_price']])
print(data_pay_7_nopay_45['pay_price'].describe())
print(data_pay_7_nopay_45['pay_count'].describe())
print('前7天合共付费：',data_pay_7_nopay_45['pay_price'].sum())  
print('前7天给钱了，但是后面45天不再给钱的：',data_pay_7_nopay_45.shape[0])

(上图)前7天付款后，45天内不再付款的有3万，占4.6万的65.5%。前7天付费34.4万，占前七天的28.1%，占前45天410万的8.4%。---（放弃不玩了？）

data_pay_7_pay_45 = copy.copy(data_pay_7[data_pay_7['pay_price']<data_pay_7['prediction_pay_price']])
print(data_pay_7_pay_45['pay_price'].describe())
print(data_pay_7_pay_45['pay_count'].describe())
print('前7天合共付费：',data_pay_7_pay_45['pay_price'].sum())  
print('前45天合共付费：',data_pay_7_pay_45['prediction_pay_price'].sum())  
print('前7天给钱了，后面45天继续给钱的：',data_pay_7_pay_45.shape[0])

(上图)前7天付款，后面继续付款的，有1.13万，占4.6万的25%，付款占410万的87.1%，而且在7天内比较快的付款第二次了。

小结：红色字体才是核心人群啊。

4、在线时长如何？

data['avg_online_minutes'].describe()

• (上图)整体来说，在线时长75%在5分钟内，看来都是下载看一下就不玩了。
• 
  

data_pay = copy.copy(data[data['pay_price']!=0])
# data_pay.shape
data_pay['avg_online_minutes'].describe()

• (上图)付费用户平均在线140分钟，除以7天，每天在线20分钟。
• 
  

5、单次付费有什么额度的？

data_once = copy.copy(data[data['pay_count']==1])
# data_once.shape  
data_once.groupby("pay_price")["pay_count"].sum()

付费次数只有一次的客户，可以看出有几种单词付费的额度，都是0.99结尾。

6、研究评估标准

评分标准是RMSE，均方根误差

如果有一个土豪客户是付费15000，但是模型只猜测是付费1000，那么(15000-1000)^2/828934=236，开根号得到15.38，一个土豪客户的误判，就可以令评分标准飙升。

如果客户是给0.99的，但是预判了1.99，那么(1.99-0.99)^2=1，开根号也是1，如果每个客户都误判1元，RMSE也就+1。

成败看土豪？？？

7、test数据集

3月10号有类似2月19号的推广活动？

消费分布跟train值非常类似

二、解决策略

盯着上面的这个图，看着看着就想到： 使用前7天付费的数据，分两步，先分类出谁会继续付款，然后回归分析继续给钱的玩家会付款多少？还有第三部分，就是忽略掉前7天没付款，但是后面45天会付款的，然后就变成以下的图了。

1、分类

》准备数据

先对数据进行一下预处理，主要是对object类的feature处理掉，没有什么归一化之类的处理的。

data = pd.read_csv("tap_fun_train.csv", parse_dates=True)

#提取object及其对应的数据
object_columns_df = data.select_dtypes(include=["object"])
#object罗列出来了。
print(object_columns_df.iloc[1])

# 有一个object特征：register_time，处理掉

data['register_time_month'] = data.register_time.str[5:7]
data['register_time_day'] = data.register_time.str[8:10]
data = data.drop(['register_time'],axis=1) 

# object转换float
data[['register_time_month','register_time_day']] = data[['register_time_month','register_time_day']].apply(pd.to_numeric)
# data=pd.DataFrame(data,dtype=np.float) 

# 对于注册时间，拆分开月和日之后，再合并一个数值，更好反馈时间的前后
data['register_time_count'] = data['register_time_month'] * 31 + data['register_time_day'] 

data.shape
# (2288007, 111)

#保存前7天会给钱的客户
data_7_pay = copy.copy(data[data['pay_price']>0])
data_7_pay.shape
# (41439, 111)
data_7_pay.to_csv ("tap_fun_train_7_pay.csv")