项目 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上对提交或更新的结果进行排名。测试集用于选举最终冠军。用于生成训练集的日志与之前生成训练集的日志相同。

1 数据预处理

1.1 lable匹配构造正负样本

暂无

1.2 各个文件join到一起

例如我的train文件第七列对应的id是queryid_tokensid.txt这个文件的第一列，如何join？

首先对两个文件按照这一行排序：

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

这里-t $'\t'表示列之间是按\t分开，-1 7 -2 1表示按照第一个文件的第七列和第二个文件的第1列来join，-a 1表示输出第一个文件中所有行（包括没匹配到的）。

但是join之后，原来两个文件的key列会跑到第一列，因此还要调整回来。写成一个脚本join.sh:

 #! /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

（注意这里awk大括号外面的$1$2...是命令行参数，大括号里面的$1$2则是表示文件的第一列第二列（域））

然后使用脚本对文件一个个的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

1.3 负采样

负采样解决的是资源有限训练数据过大，如果资源足够尽量不要采样。采样方式还是用awk编程，标签为1就输出全部域$0，标签为0就按照0.5的概率决定输不输出。

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.4 shuffle打乱顺序

sort -R train_combined >train_shuffle

1.5 训练集，测试集划分

这里按照7:3来划分验证集和测试集：

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

2 特征抽取

可以用到的特征：原数据集所有的字段，query与广告关键词，广告标题，广告描述的tf-idf相似度，广告相对深度，各种组合特征。

这里涉及到的特征处理方法有三种：

（1）one hot encoding

one hot encoding方法是针对离散型的特征，按照one-hot编码，该离散特征有多少取值，就用多少维来表示该特征。之所以要采用这种方式，是为了让离散特征向量之间的欧式距离计算显得更加合理。 这样产生出来的特征向量是稀疏的，因此要用稀疏表达来存储。

（2）离散化

对连续型特征分段然后离散化，再进行one hot encoding，也是这里采用的方法。离散化可以降低特征中包含的噪声。

（3）特征组合

将不同的特征组合起来成为新的特征。python代码如下：

  #!/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

 #这些特征加进去不一定管用，需要自己试验. list输出的就是一个one encoding的稀疏表达形式
 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
python feature_map.py validate_data validate_feature

3 模型训练

当lable为0，1时，逻辑回归损失函数的梯度如下推导：

建模代码如下

 #!/usr/bin
 # -*- coding:utf-8 -*-
 import random
 import math

 alpha = 0.1
 iter = 1
 l2 = 1 #拉姆达

 file =open("train_feature","r")

 max_index = 0
 #求出稀疏表示的特征向量有多长（最大维度）
 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.
                 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文件中，第一列表示真实值，第二列是逻辑回归预测出来的概率。

4 计算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)