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 = 0    hit = 0    Ru_total = 0     Tu_total = 0    for 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_total    precision = hit/Ru_total

    return precision,recall

def Coverage(train,I):    '''    :param train: 字典形式，训练集上给用户推荐的物品列表    :param I: 测试集上所有的物品个数    :return:返回覆盖率    '''    hit = 0     total = 0    R = set() #推荐系统能够推荐出来的物品集合    for user in train.keys():        Ru = set(train[user])        R = R|Ru

    return len(R)/I

def Popularity(train,Popularity_Di):    '''    :param train: 字典形式，训练集上给用户推荐的物品列表    :param Popularity_Di: 字典形式，物品流行度    :return:返回推荐列表的物品平均流行度    '''    R = set() #推荐系统能够推荐出来的物品集合    for user in train.keys():        Ru = set(train[user])        R = R|Ru

    P = {key:Popularity_Di[key] for key in Popularity_Di if key in R}    return sum(P.values())/len(R)

训练测试集划分

import randomfrom sklearn.model_selection import KFold

def 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)*ratio        SelectSample = popular_items[:(N+len(PositiveSample))]        NegativeSamlpe = [i for i in SelectSample if i not in PositiveSample][:N] #得到采样负样本        positive_di = dict.fromkeys(PositiveSample,1) #正样本标记为1        negative_di = dict.fromkeys(NegativeSamlpe,0) #负样本标记为0        positive_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.values    M = R.shape[0] #用户数    N = R.shape[1] #物品数    #随机初始化特征矩阵P、Q    P = 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,Qi                    for 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 = 0        for 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*:# break

    R_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()/100Popularity_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 timeimport randomuser_train_list = random.sample(list(set(train['userId'])),300)# user_train_list = list(set(train['userId']))

K = 100alpha = 0.02lamda = 0.01LFM_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个用户，耗时还是很长的，来看看结果：

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