1.LFM模型通过隐含特征联系用户与物品

2.LFM模型主要思想是对物品的兴趣进行分类，对于某个用户，首先得到他的兴趣     分类，再从分类中挑选他可能喜欢的物品

3.负采样样本数目要平衡且尽可能选择热门且用户没有行为的物品

4.LFM模型一般采用SGD求解

1.LFM模型介绍

隐语义模型（Latent Factor Model，LFM）属于机器学习算法，它通过隐含特征联系用户与物品。主要思想是：对物品的兴趣进行分类，对于某个用户，首先得到他的兴趣分类，再从分类中挑选他可能喜欢的物品。

隐语义模型将矩阵R分解为P和Q的乘积，即通过矩阵中的物品类别将用户User和物品Item联系起来。实际上需要根据用户当前的物品偏好信息R进行计算，得到相应的矩阵P和矩阵Q.

• R矩阵表示用户对物品的偏好信息，Rij代表User i对Item j的兴趣度

• P矩阵表示用户对各物品类别的一个偏好信息，Pij代表User i对Class j的兴趣度

• Q矩阵表示各个物品归属到各个类别的信息，Qij代表Item j在类别Class i的权重或概率

从隐语义模型可以得到用户对物品兴趣度公式：

2.LFM模型样本

推荐系统的用户行为分为显性反馈数据集（评分数据）和隐性反馈数据集。LFM在显性反馈数据上很好解决了评分预测问题（这里没有正负样本之分）。

而在隐性反馈数据集上，有正负样本之分。因为对于热门推荐而用户没有浏览或表达过偏好的商品，用户很大概率是看到的，但却没有行为，说明用户不喜欢这一类商品。人们发现，对于负采样应该遵循以下原则：

对每个用户，要保证正负样本的平衡（数目相似）；

对每个用户采样负样本时，要选取那些很热门而用户没有行为的物品

3.LFM模型求解

一般采用最优化损失函数求解P和Q:

该函数意义：用户u对物品i的真实兴趣度与推算出来的兴趣度的误差平方和。如果使得模型最优，则误差平方和必然应该最小。

求解该损失函数一般使用梯度下降法，最常用的是随机梯度下降法（SGD）

对两组未知参数求导，

迭代计算，直至收敛

这里需要设置四个参数：

K：隐分类个数

alpha：梯度下降步长（学习速率）

lambda：损失惩罚函数的惩罚因子

ratio：正反馈样本和负反馈样本数的比例

4.LFM模型代码实现

LFM模型算法实现步骤：

1.基于【用户，项目，评分】划分训练集与测试集

2.以比例ratio对训练数据集进行负采样，有过评分的项目打标签为1，负样本（没有过评分）打标签为0

3.生成初始用户物品偏好矩阵R(user-item)

4.设定隐分类个数K，迭代次数，学习速率和惩罚因子

5.生成初始矩阵P,Q

6.利用梯度下降公式更新P和Q

7.输出PQ,即更新后的用户物品偏好矩阵

小编用的是电影数据集进行算法实现。

数据集介绍

1.ratings.dat UserID:用户id MovieId:电影id Rating:评分 Timestamp:时间戳

2.movies.dat 电影id 电影名字 电影类别

3.users.dat 用户id 用户性别 年龄 职业 压缩编码

定义评测指标

def Recall_Precison(train,test):''':param train: 字典形式，训练集上给用户推荐的物品列表:param test: 字典形式，测试集上用户的行为列表:return:返回精准率和召回率'''hit = 0hit = 0Ru_total = 0 Tu_total = 0for user in train.keys():Tu = set(test[user])Ru = set(train[user])hit = hit + len(Ru&Tu)Ru_total = Ru_total + len(Ru)Tu_total = Tu_total + len(Tu)recall = hit/Tu_totalprecision = hit/Ru_totalreturn precision,recalldef Coverage(train,I):''':param train: 字典形式，训练集上给用户推荐的物品列表:param I: 测试集上所有的物品个数:return:返回覆盖率'''hit = 0 total = 0R = set() #推荐系统能够推荐出来的物品集合for user in train.keys():Ru = set(train[user])R = R|Rureturn len(R)/Idef Popularity(train,Popularity_Di):''':param train: 字典形式，训练集上给用户推荐的物品列表:param Popularity_Di: 字典形式，物品流行度:return:返回推荐列表的物品平均流行度'''R = set() #推荐系统能够推荐出来的物品集合for user in train.keys():Ru = set(train[user])R = R|RuP = {key:Popularity_Di[key] for key in Popularity_Di if key in R}return sum(P.values())/len(R)

训练测试集划分

import random
from sklearn.model_selection import KFolddef splitdata(data):kf = KFold(n_splits=5,random_state=0,shuffle=True) #把数据集分成5等份train,test = pd.DataFrame(),pd.DataFrame()for user in set(data['userId']):items = data[data['userId'] == user].reset_index(drop=True)k_groups = []for index in kf.split(items): #因为是5等分，即5折交叉，一共循环5次#index[0]是每一折的训练集，index[1]是每一折的测试集k_groups.append(index)i = random.randint(0,4) #随机选取一份作为测试集训练集train = pd.concat([train,items.loc[k_groups[i][0],:]],axis=0)test = pd.concat([test,items.loc[k_groups[i][1],:]],axis=0)return train,test

负样本采样

def SampleSelect(data,Popularity,ratio):''':param User:用户电影评分数据集:param Popularity:字典形式，物品流行度:param ratio:负样本比例（负样本：正样本）:return:字典形式，用户采样物品。用户id:{物品id:1,..,物品id:0},1代表正样本，0代表负样本'''Sample = dict()popular_items = [i[0] for i in sorted(Popularity.items(),key=lambda x:x[1],reverse=True)] #热门商品降序排列user_list = set(data['userId'])for user in user_list:PositiveSample = list(data[data['userId'] == user]['movieId'])N = len(PositiveSample)*ratioSelectSample = popular_items[:(N+len(PositiveSample))]NegativeSamlpe = [i for i in SelectSample if i not in PositiveSample][:N] #得到采样负样本positive_di = dict.fromkeys(PositiveSample,1) #正样本标记为1negative_di = dict.fromkeys(NegativeSamlpe,0) #负样本标记为0positive_di.update(negative_di)Sample.setdefault(user,positive_di) #把正负样本写进字典return Sample

编写核心算法（隐性反馈）

def LFM_algorithm(Sample,R,K,alpha,lamda,max_iter=1000):''':param Sample: 采样集合，字典形式:param R: 用户-物品评分矩阵:param k: 隐特征个数:param alpha: 学习速率:param lamda: 正则化参数:param max_iter: 最大迭代次数:return:用户特征矩阵P(用户与k隐类的关系),规模M*K;物品特征矩阵Q(k隐类与物品的关系),规模K*N'''item_list = [i[1] for i in R.columns]user_list = [i for i in R.index]R = R.valuesM = R.shape[0] #用户数N = R.shape[1] #物品数#随机初始化特征矩阵P、QP = np.random.rand(M,K)Q = np.random.rand(K,N)for n in range(max_iter):for u in range(M):for i in range(N):if Sample[user_list[u]].get(item_list[i],-1) != -1:#找到用户u的正负样本eui = R[u,i] - 1/(1+np.exp(-np.dot(P[u,:],Q[:,i])))#梯度下降更新Pu,Qifor k in range(K):P[u,k] = P[u,k] + alpha*(Q[k,i]*eui - lamda*P[u,k])Q[k,i] = Q[k,i] + alpha*(P[u,k]*eui - lamda*Q[k,i])alpha *= 0.9 #每次迭代降低学习率#计算损失函数值cost = 0for u in range(M):for i in range(N):if Sample[user_list[u]].get(item_list[i],-1) != -1:cost += (R[u,i] - 1/(1+np.exp(-np.dot(P[u,:],Q[:,i]))))**2
# for k in range(K): #计算正则项
# cost += lamda*(P[u,k]**2 + Q[k,i]**2)# if cost < 0.1*:
# breakR_new = pd.DataFrame(1/(1+np.exp(-np.dot(P,Q))),index=user_list,columns=item_list)return R_new,cost

编写推荐函数

def LFM_Recommand(user, R, N):''':param user: 用户id:param R: 训练好的用户物品评分矩阵:param N: 推荐物品长度:return:推荐列表，字典形式。物品id:评分'''
# NegativeSample = [i[0] for i in Sample[user].items() if i[1] == 0]ser = R.loc[user,:].sort_values(ascending=False)[:N]Recommend = dict(zip(ser.index, ser)) #物品id:兴趣度return list(Recommend.keys())

主函数

#加载并导入数据
path = r'F:\推荐系统\推荐系统开发实战\ml-1m'file_path = os.path.join(path,'ratings.dat')
rating_dt = pd.read_table(file_path,header=None,sep="::",names=['userId','movieId','rate','timesamp'],engine='python')file_path = os.path.join(path,'movies.dat')
movie_dt = pd.read_table(file_path,header=None,sep="::",names=['movieId','name','type'],engine='python')file_path = os.path.join(path,'users.dat')
user_dt = pd.read_table(file_path,header=None,sep="::",names=['userId','sex','age','job','code'],engine='python')D = rating_dt[['userId','movieId','rate']]
#物品流行度：有多少用户为某物品评分
ser = D['movieId'].value_counts()/100
Popularity_Di = dict(zip(ser.index,ser.values)) #物品流行度字典,物品id:流行度#训练测试集划分
train,test = splitdata(D)
user_train = {}
user_test = {}
for user in set(test['userId']):user_train[user] = list(train[train['userId'] == user]['movieId'])user_test[user] = list(test[test['userId'] == user]['movieId'])#计算原始user-item矩阵
R = pd.pivot_table(train,index=['userId'],columns=['movieId'],values=['rate'],aggfunc=np.alen,fill_value=0) #隐性评分

import time
import random
user_train_list = random.sample(list(set(train['userId'])),300)
# user_train_list = list(set(train['userId']))K = 100
alpha = 0.02
lamda = 0.01
LFM_li = []
for ratio in [1,2,3,5,10,20]:user_recommond = dict()Sample = SampleSelect(train,Popularity_Di,ratio)t = time.time()R_train = LFM_algorithm(Sample,R,K,alpha,lamda,max_iter=5)print('ratio {} cost time:{:.4}s,the cost function is:{:.5}'.format(ratio,(time.time() - t),R_train[1]))for user in user_train_list:user_recommond[user] = LFM_Recommand(user,R_train[0],20)r = Recall_Precison(user_recommond,user_test)cov = Coverage(user_recommond,len(set(test['movieId'])))p = Popularity(user_recommond,Popularity_Di)LFM_li.append([ratio,r[0],r[1],cov,p])LFM = pd.DataFrame(LFM_li,columns=['ratio','precision','recall','coverage','popularity'])
LFM

这里，由于本地电脑算力实在有限，小编只随机推荐了300个用户，耗时还是很长的，来看看结果：

随着负样本的增加，覆盖率会降低，而流行度会上升