【項目】搜索廣告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上對提交或更新的結果進行排名。測試集用於選舉最終冠軍。用於生成訓練集的日誌與以前生成訓練集的日誌相同。

View Code

 1. CTR預估的流程

數據 -》 預處理 -》特徵抽取 -》模型訓練 -》後處理

特徵決定了達到好的評價指標的上限，模型決定了接近這個上限的程度。

2. 數據預處理

label匹配：展現日誌和點擊日誌作一個join

採樣: 負採樣（廣告點擊率很低，隨機丟棄一部分負樣本

組合相關信息: 相關信息須要到別的文件中去找，因此須要組合相關信息。好比：若是須要查看某個query_id表明的是什麼，須要去id號對應的txt中查詢: cat queryid_tokensid.txt | awk '$1 == 14092{print $0}' | head

每次都這樣操做會比較麻煩，因此須要直接把這些信息組合到訓練數據中去。這就是數據預處理裏面的特徵組合：Join

2.1 join的shell命令是：

先對兩個文件按照他們要join的對象進行排序：而後進行join。這個join的key會被放到文件的第一列。

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

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