【项目】搜索广告CTR预估（二）

时间 2019-11-15

标签项目搜索广告 ctr 预估繁體版

原文原文链接

项目介绍html

给定查询和用户信息后预测广告点击率



      搜索广告是近年来互联网的主流营收来源之一。在搜索广告背后，一个关键技术就是点击率预测-----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上对提交或更新的结果进行排名。测试集用于选举最终冠军。用于生成训练集的日志与以前生成训练集的日志相同。

View Code

1. CTR预估的流程

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

特征决定了达到好的评价指标的上限，模型决定了接近这个上限的程度。算法

2. 数据预处理

label匹配：展现日志和点击日志作一个joinshell

采样: 负采样（广告点击率很低，随机丢弃一部分负样本bash

组合相关信息: 相关信息须要到别的文件中去找，因此须要组合相关信息。好比：若是须要查看某个query_id表明的是什么，须要去id号对应的txt中查询: cat queryid_tokensid.txt | awk '$1 == 14092{print $0}' | headsession

每次都这样操做会比较麻烦，因此须要直接把这些信息组合到训练数据中去。这就是数据预处理里面的特征组合：Joinapp

2.1 join的shell命令是：

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

awk详解：http://www.cnblogs.com/ggjucheng/archive/2013/01/13/2858470.htmlide

sort详解：http://www.2cto.com/os/201304/203309.html函数

join详解：http://www.cnblogs.com/agilework/archive/2012/04/18/2454877.html

1 先sort
2  sort -t $'\t' -k 7,7  train >train_sort
3 sort -t $'\t' -k 1,1 queryid_tokensid.txt > queryid_sort
4 
5 而后join
6 join -t $'\t' -1 7 -2 1 -a 1 train_sort queryid_sort >train1

View Code

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

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

View Code

写了一个脚原本进行这几部操做，由于key列会跑到第一列，因此作了一下调整。join代码以下：

 1 #! /bin/bash 
 2 sort -t $'\t' -k "$2,$2" $1 >t1
 3 
 4 sort -t $'\t' -k "$4,$4" $3 >t2
 5 
 6 join -t $'\t' -1 $2 -2 $4 t1 t2 -a 1|awk -v n=$2 '{
 7         s=$2;
 8         for(i=3;i<=n;++i){
 9                 s=s"\t"$i
10         }
11         s=s"\t"$1;
12         for(i=n+1;i<=NF;++i){
13                 s=s"\t"$i
14         }
15         print s
16 }'
17 
18 #rm -f t1 t2

View Code

使用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

View Code

2.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

View Code

2.3 shuffle

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

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

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

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

View Code

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

View Code

3. 特征工程

用户特征：userid, gender, age

广告特征：adid, advertesierid, titleid,keywordid, descriptionid

上下文特征：depth, position

High Level 特征：范化能力比较强的特征。四川人能吃辣。

Low Level 特征：自解释能力比较强。我朋友A能吃辣。id号

一般从刻画能力和覆盖率两个方面评判特征。

3.1 one hot encoding

这里使用 one hot encoding.由于数据量不大，直接使用map.数据量大的话可使用hash。获得的是一个稀疏矩阵，采用稀疏矩阵表示，记录哪里有“1”便可。

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 
 4 
 5 import os
 6 import sys
 7 
 8 file = open(sys.argv[1],"r")
 9 toWrite = open(sys.argv[2],"w+")
10 #feature_index表示最大的编号，函数的主要目的是产生惟一的id号，方法是前缀+id
11 feature_map={}
12 feature_index=0
13 def processIdFeature(prefix, id):
14 
15     global feature_map
16     
17     global feature_index
18 
19     str = prefix + "_" + id
20     
21     if str in feature_map:
22         return feature_map[str]
23     else:
24         feature_index = feature_index + 1
25         feature_map[str] = feature_index
26     return feature_index
27 
28 
29 #这些特征加进去不必定管用，须要本身试验. lis里面存的是他在map里面的值
30 def extracFeature1(seg):
31 
32     list=[]
33 
34     list.append(processIdFeature("url",seg[1]))
35 
36     list.append(processIdFeature("ad",seg[2]))
37 
38     list.append(processIdFeature("ader",seg[3]))
39 
40     list.append(processIdFeature("depth",seg[4]))
41 
42     list.append(processIdFeature("pos",seg[5]))
43 
44     list.append(processIdFeature("query",seg[6]))
45 
46     list.append(processIdFeature("keyword",seg[7]))
47 
48     list.append(processIdFeature("title",seg[8]))
49 
50     list.append(processIdFeature("desc",seg[9]))
51         list.append(processIdFeature("user",seg[10]))
52 
53     return list
54 
55 
56 def extracFeature2(seg):
57 
58     depth = float(seg[4])
59     pos = float(seg[5])
60     id = int (pos*10/depth)
61     return processIdFeature("pos_ratio",str(id))
62 
63 
64 def extracFeature3(seg):
65     
66     list=[]
67     if(len(seg)>16):
68         str = seg[2] + "_" + seg[15]
69         list.append(processIdFeature("user_gender",str))
70     return list
71 
72 def toStr(label, list):
73     line=label
74     for i in list:
75         line = line + "\t" +str(i) + ":1"# 这里的str(i)是指把i变成字符串
76     return line
77 
78 for line in file:
79     seg = line.strip().split("\t")
80     list = extracFeature1(seg)
81     #list.append(extracFeature2(seg))
82     #list.extend(extracFeature3(seg))
83     toWrite.write(toStr(seg[0],list)+"\n")
84 
85 
86 toWrite.close

View Code

对训练集和验证集进行encoding

python feature_map.py train_data train_feature

python feature_map.py validate_data validate_feature

若是使用Hash的话：

1 HASH_SIZE = 1000000
2 def processIdFeature(prefix, id):
3     str = prefix + "_" + id
4     return hash(str) % HASH_SIZE
5 #接下来代码都同样

View Code

3.2 离散化

　　为何要离散化？

　　离散化方法

　　好比说这里能够组合depth和pos，广告排在前1/3 中间后边的点击率感受明显不一样，因此这里可使用pos / depth的离散化值来进行新特征的建立。

3.3 特征组合

　　特征种类内部作组合，好比广告内部特征，用户内部特征等，提升自身的刻画能力，自解释能力。但也会带来覆盖率低的问题。

　　特征种类之间作组合，好比用户和广告类型。提升表达关系的能力。好比这个广告在哪段时间点击率高等。

特征工程总结：

0.对于显示特征，采用onehotencoding的方法构建特征。
1.广告位置特征：使用depth - pos / depth 离散化来构建特征
3.广告与用户检索类似性特征：分别处理用户query与广告description,title,keywords之间的类似性，以query和description为例，使用全部广告的description做为一个语料库，而后看多少广告包含了我这个query,获得一个逆文档频率，而后在用获得这个query出现的一个频率（当前包含几个除以最大那个包含几个），经过TF-IDF计算这种类似度。
4.广告类别特征。根据用户的搜索关键字和广告的购买关键字集合作一个交集，以后获得触发关键字。每个广告有一个触发关键字，能够利用触发关键字来定义两个广告之间的类似度（计算余弦类似度），以此为依据作一个k均值聚类。而后每个广告作一个类标注，做为一个特征，找到每一个类的topK个平凡的词语做为类标记。以后测试数据的时候，分别与这些类标记向量进行余弦类似度计算看属于哪一个类。
5.广告质量的衡量。广告的质量主要主要看广告的title, discription, keywords之间的类似性，可使用余弦类似度来度量。

View Code

4. 模型训练

　　特征处理完以后，使用Logestic回归进行建模以下

　　建模代码train.py以下：

 1 #!/usr/bin
 2 # -*- coding:utf-8 -*-
 3 import random
 4 import math
 5 
 6 alpha = 0.1
 7 iter = 1
 8 l2 = 1 #拉姆达
 9 
10 file =open("train_feature","r")
11 
12 max_index = 0
13 #拿到一个维度坐标最大值.找出这个map到底有多大，特征向量到底有多长 
14 for f in file :
15         seg = f.strip().split("\t")
16         for st in seg[1:]: #0不要,0是label
17                 index = int(st.split(":")[0])
18                 if index > max_index :
19                         max_index = index
20 
21 weight = range (max_index+1)
22 for i in range(max_index+1):
23         weight[i]=random.uniform(-0.01,0.01) #初始化成-0.1 到 0.1
24 
25 for i in range(iter):
26         file = open("train_feature","r")
27         for f in file:
28                 seg = f.strip().split("\t")
29                 label = int (seg[0])
30                 s = 0.0
31                 for st in seg[1:]:
32                         index = int (st.split(":")[0])
33                         #val = float(st.split(":")[1])
34                         s += weight[index] #特征值为1.其实就是一个大特征，出现了的是1，没出现的就是0.
35                        # s+=weight[index]
36                 p = 1.0/(1 + math.exp(-s)) #上面算出了wt * x。这里算的是sigmoid函数，也就是预测值是多少
37         #梯度 == 预测值 - label。原本还要 * x的，可是由于x 都为1，因此。
38                 g = p - label #这是算出来了梯度是多少。
39                 for st in seg[1:]:
40                          index = int(st.split(":")[0])
41              weight[index]-=alpha* (g +l2 * weight[index]) # w == w - alpha * (梯度g + 拉姆达l2 * w)
42 
43 #在validate_feature上验证咱们的预测效果是怎么样的。
44 file = open("validate_feature","r")
45 toWrite = open("pctr","w+") #pctr存的是预测出来的结果 表明的是实际是什么，预测出来是什么。
46 for f in file :
47         seg = f.strip().split("\t")
48         lable = int (seg[0])
49         s = 0.0
50         for st in seg[1:]:
51                 index = int(st.split(":")[0])
52                 s+= weight[index]
53         p = 1.0 /(1 + math.exp(-s))
54         s = seg[0] + "," + str(p) + "\n"
55         toWrite.write(s)
56 
57 toWrite.close()

View Code

　　若是使用AdaGrad算法的话就是梯度降低的步长不是固定的。是要除以梯度的累加和，这样致使后边的步长变小。　　

　　而后执行：

python train.py

最后生成pctr文件：第一列表示validate里面的真实值，第二列表示预测出来pctr。

5. 评价指标AUC

　　auc代码以下：

 1 #!/usr/bin/env python
 2 
 3 import sys
 4 def auc(labels,predicted_ctr):
 5     i_sorted = sorted(range(len(predicted_ctr)),key = lambda i : predicted_ctr[i],reverse = True)
 6     auc_temp = 0.0
 7     tp = 0.0
 8     tp_pre = 0.0 
 9     fp = 0.0
10     fp_pre = 0.0
11     last_value = predicted_ctr[i_sorted[0]]
12     for i in range(len(labels)):
13         if labels[i_sorted[i]] > 0:
14             tp+=1
15         else:
16             fp+=1
17         if last_value != predicted_ctr[i_sorted[i]]:
18                 auc_temp += ( tp + tp_pre ) * ( fp - fp_pre) / 2.0
19                 tp_pre = tp
20                 fp_pre = fp
21                 last_value = predicted_ctr[i_sorted[i]]
22     auc_temp += ( tp + tp_pre ) * ( fp -fp_pre ) / 2.0
23     return auc_temp / (tp * fp)
24 
25 def evaluate(ids,true_values,predict_values):
26     labels = []
27     predicted_ctr = []
28     for i in range(len(ids)):
29         labels.append(int(true_values[i]))
30         predicted_ctr.append(float(predict_values[i]))
31     return auc(labels,predicted_ctr)
32 
33 if __name__ == "__main__":
34     f = open(sys.argv[1],"r")
35     ids = []
36     true_values = []
37     predict_values = []
38     for line in f:
39         seg = line.strip().split(",")
40         ids.append(seg[0])
41         true_values.append(seg[1])
42         predict_values.append(seg[2])
43     print evaluate(ids,true_values,predict_values)

View Code

　　执行代码以下：

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