KDDCUP CTR预测比赛总结

赛题与数据介绍

给定查询和用户信息后预测广告点击率
 
      搜索广告是近年来互联网的主流营收来源之一。在搜索广告背后，一个关键技术就是点击率预测-----pCTR(predict the click-through rate)，由于搜索广告背后的经济模型（economic model ）需要pCTR的值来对广告排名及对点击定价。本次比赛提供的训练实例源于腾讯搜索引擎的会话日志(sessions logs), soso.com，要求参赛者精准预测测试实例中的广告点击率。 
 
训练数据文件TRAINING DATA FILE
 
      训练数据文件是一个文本文件，里面的每一行都是一个训练实例（源于搜索会话日志消息）。 为了理解训练数据，下面先来看看搜索会话的描述。搜索会话是用户和搜索引擎间的交互，它由这几部分构成： 用户，用户发起的查询，一些搜索引擎返回并展示给用户的广告，用户点击过的0条或多条广告。为了更清楚地理解搜索会话，这里先介绍下术语：在一个会话中展示的广告数量被称为深度（depth）， 广告在展示列表中的序号称为广告的位置(position)。广告在展示时，会展示为一条短的文本，称之为标题（title），标题后跟着一条略长些的文本和一个URL，分别叫做描述(description)和展示链接（display URL）。
 
       我们将每个会话划分为多个实例。每个实例描述在一种特定设置（比如：具有一定深度及位置值）下展示的一条广告。为了减少数据集的大小，我们利用一致的user id, ad id, query来整理实例。因此，每个实例至少包含如下信息：
 
UserID
AdID
Query
Depth
Position
Impression
      搜索会话的数量，在搜索会话中广告（AdID）展示给了发起查询(query)的用户（UserID）。
Click
      在上述展示中，用户（UserID）点击广告（AdID）的次数。
 
此外， 训练数据，验证数据及测试数据包含了更多的信息。原因是每条广告及每个用户拥有一些额外的属性。我们将一部分额外的属性包含进了训练实例，验证实例及测试实例中，并将其他属性放到了单独的数据文件中， 这些数据文件可以利用实例中的ids来编排索引。如果想对这类数据文件了解更多，请参考ADDITIONAL DATA FILES部分。
 
最后，在包括了额外特征之后，每个训练实例是一行数据（如下），这行数据中的字段由TAB字符分割：
 
1. Click： 前文已描述。
2. DisplayURL：广告的一个属性。
     该URL与广告的title（标题）及description（描述）一起展示，通常是广告落地页的短链(shortened url)。 在数据文件中存放了该URL的hash值。
3. AdID: 前文已描述。
4. AdvertiserID ： 广告的属性。
      一些广告商会持续优化其广告，因此相比其他的广告商，他们的广告标题和描述会更具魅力。
5. Depth：会话的属性，前文已描述。
6. Position： 会话中广告的属性，前文已描述。
7. QueryID： 查询的id。
      该id是从0开始的整数。它是数据文件'queryid_tokensid.txt'的key。
8.KeywordID : 广告的属性。
      这是 'purchasedkeyword_tokensid.txt'的key。
9.TitleID: 广告的属性。
      这是 'titleid_tokensid.txt'的key。
10.DescriptionID：广告的属性。
      这是'descriptionid_tokensid.txt'的key。
11. UserID
      这是 'userid_profile.txt'的key。当我们无法确定一个用户时，UserID为0。
 
附加的数据文件ADDITIONAL DATA FILES
 
这里还有前面提到过的5个附加的数据文件：
 
1. queryid_tokensid.txt
 
2. purchasedkeywordid_tokensid.txt
 
3. titleid_tokensid.txt
 
4. descriptionid_tokensid.txt
 
5. userid_profile.txt
 
      前4个文件每一行将id映射为一个记号列表，在query（查询）, keyword（关键字）, ad title（广告标题）及ad description（广告描述）中都是如此。 在每一行中，TAB字符将id及其他记号集分隔开。一个记号最基本可以是自然语言中的一个词。为了匿名，每个记号以hash后的值来表示。 字段以 ‘|’分割。
 
‘userid_profile.txt’ 文件的每一行由UserID, Gender, 和 Age组成，用TAB字符来分隔。注意，并非训练集和测试集中的每个UserID都会出现在‘userid_profile.txt’文件中。每个字段描述如下：
1. Gender:
'1' for male(男), '2' for female（女）, and '0' for unknown（未知）.
2. Age:
'1' for (0, 12], '2' for (12, 18], '3' for (18, 24], '4' for (24, 30], '5'
for (30, 40], and '6' for greater than 40（6代表大于40）.
 
TESTING DATASET（测试数据集）
 
       除了广告展示及广告点击的数量不同外，测试数据集与训练数据集的格式一致。 广告展示及广告点击次数用于计算先验的点击率（empirical CTR）。 训练集的子集用于在leaderboard上对提交或更新的结果进行排名。测试集用于选举最终冠军。用于生成训练集的日志与之前生成训练集的日志相同。

0，CTR预估的流程：

数据-》预处理数据-》特征抽取-》模型训练-》后处理。

特征决定了达到好的评价指标的天花板，好的模型决定了到达这个天花板的能力。所以，特征的处理是非常重要的。

1.join

特征在预处理的时候要进行相关信息组合 Linux的join相关：（注意sort a > a没有-o会清空内容.应该用sort a -o a）

http://www.runoob.com/linux/linux-comm-join.html

http://www.cnblogs.com/51linux/archive/2012/05/23/2515299.html

join之前要排序。

关于数据集：如果要看某个id好代表什么，都可以去他的id号对应的txt查询：cat queryid_tokensid.txt | awk '$1 == 14092{print $0}' | head

那么，每一次每个样本都还要去txt里面找它对应的信息，就会导致非常繁琐。那么需要这些特征，就可以把他们整合在一起。

这就是数据预处理里面的特征组合：Join：

join的shell命令是：先对两个文件按照他们要join的对象进行排序：然后进行join。这个join的key会被放到文件的第一列。

代码如下：

先sort
 sort -t $'\t' -k 7,7  train >train_sort
sort -t $'\t' -k 1,1 queryid_tokensid.txt > queryid_sort
 
然后join
join -t $'\t' -1 7 -2 1 -a 1 train_sort queryid_sort >train1

join之后看一下多少行，来验证是否join进去了。发现从11列变成了12列。代码如下：

head train | awk '{print NF} 显示11列
head train1 | awk '{print NF}显示12列

写了一个脚本来进行这几部操作，因为key列会跑到第一列，所以做了一下调整。join代码如下：

#! /bin/bash
sort -t $'\t' -k "$2,$2" $1 >t1
 
sort -t $'\t' -k "$4,$4" $3 >t2
 
join -t $'\t' -1 $2 -2 $4 t1 t2 -a 1|awk -v n=$2 '{
        s=$2;
        for(i=3;i<=n;++i){
                s=s"\t"$i
        }
        s=s"\t"$1;
        for(i=n+1;i<=NF;++i){
                s=s"\t"$i
        }
        print s
}'
 
#rm -f t1 t2

使用join.sh对每一个文件进行join，命令如下：

bash join.sh train 7 queryid_tokensid.txt 1 > train1
bash join.sh train1 8 purchasedkeywordid_tokensid.txt  1 > train2
bash join.sh train2 9 titleid_tokensid.txt  1 > train3
bash join.sh train2 10 descriptionid_tokensid.txt  1 > train4
bash join.sh train4 11 userid_profile.txt  1 > train5

2，负样本采样，对负样本进行随机丢弃，代码：

awk 'BEGIN{srand()}{if($1==1)print $0;if($1==0)if(rand() > 0.5)print $0}' train_combined > t
 
数一下行数：
wc -l t
wc -l train5

对负样本采样的原因：

在负样本较多的情况下，为了实现更加准确的预测，需要更大的数据集来获得更多的正样本，对负样本进行采样以后，在样本集大小变小的情况下，正样本的比率增大了。

总样本数1亿条左右，其中正样本数100万条，采样之后正负样本比例1:5，也试过1:4，1:6，1:5效果比较好。采样是用hadoop streaming实现的。

3,洗牌一下。把train和validate数据给分出来：

这里的数据把train里面的数据分成7:3的训练数据和验证数据。

数据说明：train是用来调特征的。validate是用来做验证的，也就是把那个train_data所出来的weights来算一下validate。

clear
[s-44@CH-46 mydata2]$ sort -R train_combined > train_shuffle

head -n 700000 train_shuffle > train_data
tail -n 300000 train_shuffle > validate_data

4，特征处理方法：

这里用one hot encoding处理。下面是代码feature_map.py：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import os
import sys
 
file = open(sys.argv[1],"r")
toWrite = open(sys.argv[2],"w+")
#feature_index表示最大的编号，函数的主要目的是产生唯一的id号，方法是前缀+id
feature_map={}
feature_index=0
def processIdFeature(prefix, id):
 
    global feature_map
 
    global feature_index
 
    str = prefix + "_" + id
 
    if str in feature_map:
        return feature_map[str]
    else:
        feature_index = feature_index + 1
        feature_map[str] = feature_index
    return feature_index
 
#这些特征加进去不一定管用，需要自己试验. lis里面存的是他在map里面的值
def extracFeature1(seg):
 
    list=[]
 
    list.append(processIdFeature("url",seg[1]))
 
    list.append(processIdFeature("ad",seg[2]))
 
    list.append(processIdFeature("ader",seg[3]))
 
    list.append(processIdFeature("depth",seg[4]))
 
    list.append(processIdFeature("pos",seg[5]))
 
    list.append(processIdFeature("query",seg[6]))
 
    list.append(processIdFeature("keyword",seg[7]))
 
    list.append(processIdFeature("title",seg[8]))
 
    list.append(processIdFeature("desc",seg[9]))
        list.append(processIdFeature("user",seg[10]))
 
    return list
 
def extracFeature2(seg):
 
    depth = float(seg[4])
    pos = float(seg[5])
    id = int (pos*10/depth)
    return processIdFeature("pos_ratio",str(id))
 
def extracFeature3(seg):
 
    list=[]
    if(len(seg)>16):
        str = seg[2] + "_" + seg[15]
        list.append(processIdFeature("user_gender",str))
    return list
 
def toStr(label, list):
    line=label
    for i in list:
        line = line + "\t" +str(i) + ":1"# 这里的str(i)是指把i变成字符串
    return line
 
for line in file:
    seg = line.strip().split("\t")
    list = extracFeature1(seg)
    #list.append(extracFeature2(seg))
    #list.extend(extracFeature3(seg))
    toWrite.write(toStr(seg[0],list)+"\n")
 
toWrite.close

然后执行命令是：

python feature_map.py train_data train_feature

然后对validate_data也做这个处理：

python feature_map.py validate_data validate_feature

5，特征处理完了之后，进行建模预测：

建模代码train.py如下：

#!/usr/bin
# -*- coding:utf-8 -*-
import random
import math
 
alpha = 0.1
iter = 1
l2 = 1 #拉姆达
 
file =open("train_feature","r")
 
max_index = 0
#拿到一个维度坐标最大值.找出这个map到底有多大，特征向量到底有多长
for f in file :
        seg = f.strip().split("\t")
        for st in seg[1:]: #0不要,0是label
                index = int(st.split(":")[0])
                if index > max_index :
                        max_index = index
 
weight = range (max_index+1)
for i in range(max_index+1):
        weight[i]=random.uniform(-0.01,0.01) #初始化成-0.1 到 0.1
 
for i in range(iter):
        file = open("train_feature","r")
        for f in file:
                seg = f.strip().split("\t")
                label = int (seg[0])
                s = 0.0
                for st in seg[1:]:
                        index = int (st.split(":")[0])
                        #val = float(st.split(":")[1])
                        s += weight[index] #特征值为1.其实就是一个大特征，出现了的是1，没出现的就是0.
                       # s+=weight[index]
                p = 1.0/(1 + math.exp(-s)) #上面算出了wt * x。这里算的是sigmoid函数，也就是预测值是多少
        #梯度 == 预测值 - label。本来还要 * x的，但是因为x 都为1，所以。
                g = p - label #这是算出来了梯度是多少。
                for st in seg[1:]:
                         index = int(st.split(":")[0])
             weight[index]-=alpha* (g +l2 * weight[index]) # w == w - alpha * (梯度g + 拉姆达l2 * w)
 
#在validate_feature上验证我们的预测效果是怎么样的。
file = open("validate_feature","r")
toWrite = open("pctr","w+") #pctr存的是预测出来的结果 代表的是实际是什么，预测出来是什么。
for f in file :
        seg = f.strip().split("\t")
        lable = int (seg[0])
        s = 0.0
        for st in seg[1:]:
                index = int(st.split(":")[0])
                s+= weight[index]
        p = 1.0 /(1 + math.exp(-s))
        s = seg[0] + "," + str(p) + "\n"
        toWrite.write(s)
 
toWrite.close()

然后进行建模：

python train.py

得到pctr文件：第一列表示validate里面的真实值，第二列表示预测出来的。

6，用auc对测试的结果进行评估：

auc代码如下：

#!/usr/bin/env python
 
import sys
def auc(labels,predicted_ctr):
    i_sorted = sorted(range(len(predicted_ctr)),key = lambda i : predicted_ctr[i],reverse = True)
    auc_temp = 0.0
    tp = 0.0
    tp_pre = 0.0
    fp = 0.0
    fp_pre = 0.0
    last_value = predicted_ctr[i_sorted[0]]
    for i in range(len(labels)):
        if labels[i_sorted[i]] > 0:
            tp+=1
        else:
            fp+=1
        if last_value != predicted_ctr[i_sorted[i]]:
                auc_temp += ( tp + tp_pre ) * ( fp - fp_pre) / 2.0
                tp_pre = tp
                fp_pre = fp
                last_value = predicted_ctr[i_sorted[i]]
    auc_temp += ( tp + tp_pre ) * ( fp -fp_pre ) / 2.0
    return auc_temp / (tp * fp)
 
def evaluate(ids,true_values,predict_values):
    labels = []
    predicted_ctr = []
    for i in range(len(ids)):
        labels.append(int(true_values[i]))
        predicted_ctr.append(float(predict_values[i]))
    return auc(labels,predicted_ctr)
 
if __name__ == "__main__":
    f = open(sys.argv[1],"r")
    ids = []
    true_values = []
    predict_values = []
    for line in f:
        seg = line.strip().split(",")
        ids.append(seg[0])
        true_values.append(seg[1])
        predict_values.append(seg[2])
    print evaluate(ids,true_values,predict_values)

执行：

cat pctr | awk '{print NR "," $0}' > t
python auc.py t

这样就得到了auc的结果。

连续型特征：

1.广告的相对位置=(depth - position)/depth，深度和位置，某一个广告的点击次数

2.query，keyword，title，description的各自的数量

3.tf-idf与余弦相似度的计算

对query，keyword，title，description计算tf-idf，文档集就是每个样本这四个文本构成的文档集，每个文本相当于一个文档。并且由此计算两两之间的余弦相似度，这样就由四个特征构造出了六个特征。

关键词选几个我的想法是根据当前词的数量的30%，如果小于1则选1，试了好几个百分比，但是30%是最好的。

关于tf-idf与余弦相似度的计算

　　（1）使用TF-IDF算法，找出两篇文章的关键词；

　　（2）每篇文章各取出若干个关键词（比如20个），合并成一个集合，计算每篇文章对于这个集合中的词的词频（为了避免文章长度的差异，可以使用相对词频）；

　　（3）生成两篇文章各自的词频向量；

　　（4）计算两个向量的余弦相似度，值越大就表示越相似。

利用GBDT构造特征--针对连续特征

30棵树，每棵树深度为6，可以说是调参调出来的最好的结果，这样就新增了30个特征。

GBDT与LR的融合方式，Facebook的paper有个例子如下图2所示，图中Tree1、Tree2为通过GBDT模型学出来的两颗树，x为一条输入样本，遍历两棵树后，x样本分别落到两颗树的叶子节点上，每个叶子节点对应LR一维特征，那么通过遍历树，就得到了该样本对应的所有LR特征。由于树的每条路径，是通过最小化均方差等方法最终分割出来的有区分性路径，根据该路径得到的特征、特征组合都相对有区分性，效果理论上不会亚于人工经验的处理方式。

图2

GBDT模型的特点，非常适合用来挖掘有效的特征、特征组合。业界不仅GBDT+LR融合有实践，GBDT+FM也有实践，2014 Kaggle CTR竞赛冠军就是使用GBDT+FM，可见，使用GBDT融合其它模型是非常值得尝试的思路[11]。

gbdt+lr的实现

笔者调研了Facebook、Kaggle竞赛关于GBDT建树的细节，发现两个关键点：采用ensemble决策树而非单颗树；建树采用GBDT而非RF（Random Forests）。解读如下：

1）为什么建树采用ensemble决策树？

一棵树的表达能力很弱，不足以表达多个有区分性的特征组合，多棵树的表达能力更强一些。GBDT每棵树都在学习前面棵树尚存的不足，迭代多少次就会生成多少颗树。按paper以及Kaggle竞赛中的GBDT+LR融合方式，多棵树正好满足LR每条训练样本可以通过GBDT映射成多个特征的需求。

2）为什么建树采用GBDT而非RF？

RF也是多棵树，但从效果上有实践证明不如GBDT。且GBDT前面的树，特征分裂主要体现对多数样本有区分度的特征；后面的树，主要体现的是经过前N颗树，残差仍然较大的少数样本。优先选用在整体上有区分度的特征，再选用针对少数样本有区分度的特征，思路更加合理，这应该也是用GBDT的原因。

http://www.cbdio.com/BigData/2015-08/27/content_3750170.htm

https://breezedeus.github.io/2014/11/19/breezedeus-feature-mining-gbdt.html#fn:fbgbdt

kaggle冠军的实现

l1正则scikit-learn中只能选择liblinear来优化，内部使用了坐标轴下降

l2正则scikit中可以有四种优化方法，选择的是sag（随机平均梯度下降），比sgd收敛速度要快