贝叶斯个性化排序(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稍微差了一点，但是感觉理解实现起来比较简单，貌似在电商实践上也有很好的实用性。
