BPR-贝叶斯个性化排序

贝叶斯个性化排序(Bayesian Personalized Ranking, 以下简称BPR)

背景

为什么要设计BPR算法呢，因为在有些推荐场景下，我们并不是想知道用户对某个商品的评分或者喜好，我们只想知道用户对某些商品的特殊偏好，如果同时出现两个商品，用户会倾向于选择哪个商品。这也是一种排序算法，排序算法不是用来学习用户的具体喜好，而是去学习用户的偏好，就算是两个不喜欢的，在用户心中也会有优先级。BPR就是一种基于pair的排序算法。

BPR模型

BPR模型本质上是一种矩阵分解算法，所以其模型本质上是为了将用户物品矩阵分解成两个低维矩阵，再由两个低维矩阵相乘后得到完整的矩阵。

因此我们需要学习的权重参数有个

损失函数

BPR算法与传统SVD算法的区别在于其损失函数的差别。因为针对评分预测，传统SVD算法的损失函数直接采用最小二乘作为其损失函数。然而考虑了用户偏好排序的BPR算法则设计了一种新的损失函数。

说来也简单，BPR算法的思路就是采用贝叶斯最大后验概率，这里的后验概率即为：

这里即为真实样本中用户的排序情况，这里提一下，BPR模型的样本是什么。BPR模型的样本由三元组组成，其中i为用户有过行为的物品，j表示用户没有行为的物品，模型认为用户对于有过行为的物品，比起没有行为的物品，要更加偏爱，那么如何用损失函数表达这种偏爱关系呢？
通过最大化后验概率！
也就是说如果用户的历史行为商品中出现了i，但是没有出现j，那么就说明出现了一个，这个代表,根据最大后验概率，我们只要是样本集中出现的样本概率最大即可，因为只要出现了就说明概率比较大嘛。那么问题来了，如何表示呢？
这个就可以去想象了，表示概率通常用的函数，逻辑回归是如何表示概率的呢？当然是logistic函数了，至于为啥这个应该是为了方便计算吧。那么公式就出来了

那么这个X是啥呢？别忘了我们是要做矩阵分解的，当然跟我们的矩阵相关了，那么如何用矩阵去表达这个X。首先想想X的特性是啥，X表达的是i与j的顺序关系，那么不难想像，如果用户比起更喜欢的话，那么矩阵中的分数是不是要比更高一点呢，我们希望更高一点，所以直接让不就好了。

最后再来点细节，根据独立同分布原则：

为了优化计算，将乘法转成加法，在前面加个log函数，ok！
至于建模参考线性回归介绍最小二乘时候的贝叶斯假设。就是直接可以变成正则项啦
总之，

参数梯度更新

对参数更新，就是求偏导的过程嘛
这个部分打字好麻烦哦，还是手写好了

因为是最大化损失函数，所以参数在更新时是相加
梯度更新：

numpy 代码实现

# -*- coding: utf-8 -*-

import math
import numpy as np
# #from collections import defaultdict
# from utils.mathfunctions import sigmoid
from  sklearn.metrics import roc_auc_score 

class BPR(object):
    '''隐式行为算法'''
    def __init__(self, config, dl):
        self.config = config
        self.dl = dl
        self.lRate = self.config.lr
        self.regU = self.config.regU
        self.regI = self.config.regI1
        self.initModel()
    def initModel(self):
        self.P = np.random.rand(self.dl.num_users, self.config.embedding_size)/3
        self.Q = np.random.rand(self.dl.num_items, self.config.embedding_size)/3
    def buildModel(self):
        for u, uhist in enumerate(self.dl.trainset()):
            history,_ = zip(*uhist)
            for i in history:
                j = np.random.choice(self.dl.num_items)
                while j in history:
                    j =  np.random.choice(self.dl.num_items)
                self._optimize(u,i,j)
    def sigmoid(self, x):
        return 1/(1+math.exp(-x))
       
    def _optimize(self,u,i,j):
        s = self.sigmoid(self.P[u].dot(self.Q[i]) - self.P[u].dot(self.Q[j]))
        self.P[u] += self.lRate * (1 - s) * (self.Q[i] - self.Q[j])
        self.Q[i] += self.lRate * (1 - s) * self.P[u]
        self.Q[j] -= self.lRate * (1 - s) * self.P[u]

        self.P[u] -= self.lRate * self.regU * self.P[u]
        self.Q[i] -= self.lRate * self.regI * self.Q[i]
        self.Q[j] -= self.lRate * self.regI * self.Q[j]
        self.loss += -math.log(s)
    
    def train_and_evaluate(self):
        print('training...')
        iter = 0
        while iter < self.config.epoches:
            self.loss = 0
            self.buildModel()
            self.loss += self.regU * (self.P * self.P).sum() + self.regI * (self.Q * self.Q).sum()
            print('loss:%.10f, P:%.4f'%(self.loss, np.mean(self.P)))
            if iter % 1 ==0 :
                self.evaluate()
            iter += 1 
#            if self.isConverged(iter):
#                break
    def predict(self, u, i):
        yui = self.sigmoid(self.Q[i].dot(self.P[u]))
        return yui
 
         

总结

我对这个算法直观的理解就是贝叶斯定理和矩阵分解的漂亮结合，效果上比ALS稍微差了一点，但是感觉理解实现起来比较简单，貌似在电商实践上也有很好的实用性。

参考

[1] 贝叶斯个性化排序(BPR)算法小结
[2] https://github.com/Coder-Yu/RecQ