排序學習(learning to rank)中的ranknet pytorch簡單實現

一.理論部分

　　理論部分網上有許多，自己也簡單的整理了一份，這幾天會貼在這里，先把代碼貼出，后續會優化一些寫法，這里將訓練數據寫成dataset,dataloader樣式。

　　排序學習所需的訓練樣本格式如下：

　　

　　解釋：其中第二列是query id，第一列表示此query id與這條樣本的相關度（數字越大，表示越相關），從第三列開始是本條樣本的特征向量。

• RankNet：

         RankNet是屬於pairwise方法，它是將某個query下的所有文檔兩兩組成文檔對，每個文檔對作為一個樣本：

　　A.  預測相關性概率：

        

　　解釋：對於任一個doc對(Ui，Uj)，模型輸出的得分為si和sj，那么根據模型預測Ui比Uj與query更相關的概率。RankNet一般采用神經網絡，sigmoid能提供一個較好的概率評估。

　　B.  真實相關性概率：

        

　　解釋：真實數據對中的Ui和Uj都包含一個與query相關度的label，比如Ui為3，Uj為1，則Ui比Uj與query更相關，這里是定義Ui比Uj更相關的真實概率。Sij定義為1：Ui比Uj更相關；-1：Uj比Ui更相關；0：Ui與Uj相關度相同。

　　C.  代價函數：

        

　　解釋：這里使用交叉熵來擬合真實概率與預測概率，兩個分布越接近，交叉熵越小。

　　D.  問題：

　　問題一：沒有使用排序中的一些評估指標直接作為代價函數，原因是這些指標函數不連續，不好求導，不太好用梯度下降，交叉熵適合梯度下降。

　　問題二：在正常訓練時，對每個樣本對{i,j}都會更新一次參數，采用BP時，更新一次需要先前向預測，再誤差后反向傳播，會很慢。

　　E.在實際使用中，ranknet采用神經網絡方法進行學習，一般采用的是帶有隱層的神經網絡。學習過程一般使用誤差反向傳播方法來訓練。

  如何訓練呢？這里提供了兩種思路：
     1）取一個樣本對(Xi, Xj)，首先對Xi帶入神經網絡進行前向反饋，其次將Xj帶入神經網絡進行前向反饋，
     然后計算差分結果並進行誤差反向傳播，接着取下一個樣本對。這種方法很直觀，缺點是收斂速度慢。
     2）批量訓練。我們可以對同一個排序下的所有文檔pair全部帶入神經網絡進行前向反饋，
     然后計算總差分並進行誤差反向傳播，這樣將大大減少誤差反向傳播的次數。

 

　　大家可以參考論文《From RankNet to LambdaRank to LambdaMART: An Overview》，這篇論文從RankNet，LambdaRank講到LambdaMart的這三種排序學習方法，后面的都是在前面的基礎上進行改進提出的。基中RankNet來自論文《Learning to Rank using Gradient Descent》，LambdaRank來自論文《Learning to Rank with Non-Smooth Cost Functions》，LambdaMart來自《Selective Gradient Boosting for Effective Learning to Rank》。RankNet與LambdaRank是神經網絡模型，LambdaRank加速了計算和引入了排序的評估指標NDCG，提出了lambda概念。而LambdaMart的核心則是利用了GBDT，即MART，這里每棵樹擬合的不是殘差(平方損失的梯度是殘差，其它損失叫負梯度)，而是Lambda這個值，這個值代表這篇文檔在下次迭代時的方向和強度，lambdamart不需要顯式定義損失函數，更加不需要對損失函數求導（因為ndcg非連續），lambda充當了擬合目標，在實際計算時，會為每個文檔計算一個lambda值。

　　......

二.pytorch實現RankNet

import torch
import torch.utils.data as data
import numpy as np

y_train = []
x_train = []
query_id = []
array_train_x1 = []
array_train_x0 = []

def extract_features(toks):
    # 獲取features
    features = []
    for tok in toks:
        features.append(float(tok.split(":")[1]))
    return features

def extract_query_data(tok):
    #獲取queryid documentid
    query_features = [tok.split(":")[1]] #qid
    return query_features

def get_format_data(data_path):
    with open(data_path, 'r', encoding='utf-8') as file:
        for line in file:
            data, _, comment = line.rstrip().partition("#")
            toks = data.split()
            y_train.append(int(toks[0])) #相關度
            x_train.append(extract_features(toks[2:])) # doc features
            query_id.append(extract_query_data(toks[1])) #qid

def get_pair_doc_data(y_train, query_id):
    #兩兩組合pair
    pairs = []
    tmp_x0 = []
    tmp_x1 = []
    for i in range(0, len(query_id) - 1):
        for j in range(i + 1, len(query_id)):
            #每個query下的文檔
            if query_id[i][0] != query_id[j][0]:
                break
            #使用不同相關度的文檔pair
            if (query_id[i][0] == query_id[j][0]) and (y_train[i] != y_train[j]):
                #將最相關的放在前面,保持文檔pair中第一個doc比第二個doc與query更相關
                if y_train[i] > y_train[j]:
                    pairs.append([i,j])
                    tmp_x0.append(x_train[i])
                    tmp_x1.append(x_train[j])
                else:
                    pairs.append([j,i])
                    tmp_x0.append(x_train[j])
                    tmp_x1.append(x_train[i])
    #array_train_x0里和array_train_x1里對應的下標元素，保持前一個元素比后一個元素更相關
    array_train_x0 = np.array(tmp_x0)
    array_train_x1 = np.array(tmp_x1)
    print('fond {} doc pairs'.format(len(pairs)))
    return len(pairs), array_train_x0, array_train_x1

class Dataset(data.Dataset):
    '''
    torch.utils.data.Dataset 是一個表示數據集的抽象類. 你自己的數據集一般應該繼承Dataset, 並且重寫下面的方法:
    __len__使用len(dataset) 可以返回數據集的大小
    __getitem__ 支持索引, 以便於使用 dataset[i] 可以 獲取第i個樣本(0索引)
    數據集創建一個數據集類. 我們使用 __init__方法來初始化, 使用 __getitem__根據索引讀取樣本.
    這樣可以使內存高效利用, 因為我們並不需要在內存中一次存儲所有圖片, 而是按需讀取.
    '''
    def __init__(self, data_path):
        # 解析訓練數據
        get_format_data(data_path)
        # pair組合
        self.datasize, self.array_train_x0, self.array_train_x1 = get_pair_doc_data(y_train, query_id)

    def __getitem__(self, index):
        data1 = torch.from_numpy(self.array_train_x0[index]).float()
        data2 = torch.from_numpy(self.array_train_x1[index]).float()
        return data1, data2

    def __len__(self):
        return self.datasize

def get_loader(data_path, batch_size, shuffle, num_workers):
    dataset = Dataset(data_path)
    data_loader = torch.utils.data.DataLoader(
        dataset=dataset,
        batch_size = batch_size,
        shuffle = shuffle,
        num_workers=num_workers
    )
    return data_loader

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import os

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

class RankNet(nn.Module):
    def __init__(self, inputs, hidden_size, outputs):
        super(RankNet, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(inputs, hidden_size),
            #nn.Dropout(0.5),
            nn.ReLU(inplace=True),
            #nn.LeakyReLU(0.2,  inplace=True),#inplace為True，將會改變輸入的數據 ，否則不會改變原輸入，只會產生新的輸出
            nn.Linear(hidden_size, outputs),
            #nn.Sigmoid()
        )
        self.sigmoid = nn.Sigmoid()

    def forward(self, input_1, input_2):
        result_1 = self.model(input_1) #預測input_1得分
        result_2 = self.model(input_2) #預測input_2得分
        pred = self.sigmoid(result_1 - result_2) #input_1比input_2更相關概率
        return pred

    def predict(self, input):
        result = self.model(input)
        return result

def train():
    # 超參
    inputs = 38
    hidden_size = 10
    outputs = 1
    learning_rate = 0.2
    num_epochs = 100
    batch_size = 100

    model = RankNet(inputs, hidden_size, outputs).to(device)
    #損失函數和優化器
    criterion = nn.BCELoss()
    optimizer = optim.Adadelta(model.parameters(), lr = learning_rate)

    base_path = os.path.abspath(os.path.join(os.getcwd(), '..'))
    base_path = os.path.dirname(base_path)
    data_path = base_path + '/goods_data/train/train_result.txt'

    data_loader = get_loader(data_path, batch_size, False, 4)
    total_step = len(data_loader)
    #  這里使用batch size的方式,並非每次傳入一對docs進行前向和后向傳播
    # (tips:還有一種是將每個query下的所有docs對作為batch輸入到網絡中進行前向和后向，但是這里沒法用到Dataset和DataLoader)
    for epoch in range(num_epochs):
        for i, (data1, data2) in enumerate(data_loader):
            print('Epoch [{}/{}], Step [{}/{}]'.format(epoch, num_epochs, i, total_step))
            data1 = data1.to(device)
            data2 = data2.to(device)
            label_size = data1.size()[0]
            pred = model(data1, data2)
            loss = criterion(pred, torch.from_numpy(np.ones(shape=(label_size, 1))).float().to(device))
            optimizer.zero_grad()
            loss.bachward()
            optimizer.step()
        if i % 10 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
                  .format(epoch + 1, num_epochs, i + 1, total_step, loss.item()))

    torch.save(model.state_dict(), 'model.ckpt')

def test():
    #test data
    base_path = os.path.abspath(os.path.join(os.getcwd(), '..'))
    base_path = os.path.dirname(base_path)
    test_path = base_path + '/goods_data/test/test_result.txt'

    # 超參
    inputs = 38
    hidden_size = 10
    outputs = 1
    model = RankNet(inputs, hidden_size, outputs).to(device)
    model.load_state_dict(torch.load('model.ckpt'))

    with open(test_path, 'r', encoding='utf-8') as f:
        features = []
        for line in f:
            toks = line.split()
            feature = []
            for tok in toks[2:]:
                _, value = tok.split(":")
                feature.append(float(value))
            features.append(feature)
        features = np.array(features)
    features = torch.from_numpy(features).float().to(device)
    predict_score = model.predict(features)