【項目】搜索廣告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. 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

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

 

2.3 shuffle

洗牌一下。把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

 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”即可。

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

對訓練集和驗證集進行encoding

python feature_map.py train_data train_feature

python feature_map.py validate_data validate_feature

 如果使用Hash的話：

HASH_SIZE = 1000000
def processIdFeature(prefix, id):
    str = prefix + "_" + id
    return hash(str) % HASH_SIZE
#接下來代碼都一樣

 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之間的相似性，可以使用余弦相似度來度量。

 

4. 模型訓練

　　特征處理完之后，使用Logestic回歸進行建模如下

　　建模代碼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()

　　如果使用AdaGrad算法的話就是梯度下降的步長不是固定的。是要除以梯度的累加和，這樣導致后邊的步長變小。　　

　　

　　然后執行：

python train.py

最后生成pctr文件：第一列表示validate里面的真實值，第二列表示預測出來pctr。

5. 評價指標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