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