排序学习(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)