LF推导及实现

执行LFM需要给定4个参数：分类数F，迭代次数N，学习速率α，正则化参数λ。

# coding:utf-8
import pandas as pd
import numpy as np
import math
import operator
import time
import random

'''
def LFM(user_items, F, N, alpha, lambda):
   #初始化P,Q矩阵
   [P, Q] = InitModel(user_items, F)
   #开始迭代
   For step in range(0, N):
      #从数据集中依次取出user以及该user喜欢的iterms集
      for user, items in user_item.iterms():
         #随机抽样，为user抽取与items数量相当的负样本，并将正负样本合并，用于优化计算
         samples = RandSelectNegativeSamples(items)
         #依次获取item和user对该item的兴趣度
         for item, rui in samples.items():
            #根据当前参数计算误差
            eui = eui - Predict(user, item)
            #优化参数
            for f in range(0, F):
               P[user][f] += alpha * (eui * Q[f][item] - lambda * P[user][f])
               Q[f][item] += alpha * (eui * P[user][f] - lambda * Q[f][item])
      #每次迭代完后，都要降低学习速率。一开始的时候由于离最优值相差甚远，因此快速下降；
      #当优化到一定程度后，就需要放慢学习速率，慢慢的接近最优值。
      alpha *= 0.9
'''

#随机p，q
def initpara(users, items, F):
    p = dict()
    q = dict()
    for userid in users:
        p[userid] = [(-1 + 2 * random.random()) for f in range(0, F)]  # / math.sqrt(F)
    for itemid in items:
        q[itemid] = [(-1 + 2 * random.random()) for f in range(0, F)]  # / math.sqrt(F)
    return p, q

#根据user_items生成user_samples(用户评分)
def initsamples(user_items):
    user_samples = []
    for userid, items in user_items.items():
        samples = dict()
        for itemid, score in items.items():
            if score != 0:
                samples[itemid] = score
        user_samples.append((userid, samples))
    return user_samples

#初始化模型，调用initpara，initsamples
def initmodel(user_items, users, items, F):
    p, q = initpara(users, items, F)
    user_samples = initsamples(user_items)
    return p, q, user_samples

#预测值
def predict(userid, itemid, p, q):
    a = sum(p[userid][f] * q[itemid][f] for f in range(0, len(p[userid])))
    return a

#LF训练p,q矩阵，调用initsamples，predict
def lfm(user_items, users, items, F, N, alpha, lamda):
    '''
    :param user_items: user_items
    :param users:      users
    :param items:      items
    :param F:          隐类因子个数
    :param N:          迭代次数
    :param alpha:      步长（学习率）
    :param lamda:      正则化参数
    :return: p,q
    '''
    p, q, user_samples = initmodel(user_items, users, items, F)

    #debugid1 = 0#正样本
    #debugid2 = 0#负样本
    for step in range(0, N):
        random.shuffle(user_samples)  # 乱序
        error = 0
        count = 0
        for userid, samples in user_samples:
            for itemid, rui in samples.items():
                pui = predict(userid, itemid, p, q)
                eui = rui - pui#实际评分减去预测得分，误差
                count += 1
                error += math.pow(eui, 2)
                '''
                #debug,以用户1为例
                #分别将item分为正负样本
                if userid == 1:
                    if debugid1 == 0 and rui == 1:
                        debugid1 = itemid
                    if debugid2 == 0 and rui == -1:
                        debugid2 = itemid
                
                if userid == 1 and itemid == debugid1:
                    print(debugid1,rui,pui,eui,alpha)
                if userid == 1 and itemid == debugid2:
                    print(debugid2,rui,pui,eui,alpha)
                
                #debug end
                '''
                #更新p，q
                for f in range(0, F):
                    p_u = p[userid][f]
                    q_i = q[itemid][f]
                    p[userid][f] += alpha * (eui * q_i - lamda * p_u)
                    q[itemid][f] += alpha * (eui * p_u - lamda * q_i)
        #计算误差
        rmse = math.sqrt(error / count)
        print("标准误差rmse:", rmse)
        #学习率下降
        alpha *= 0.9
    return p, q

#所有user对所有item预测得分，测试，调用predict
def predictlist(userid, items, p, q):
    predict_score = dict()
    for itemid in items:
        p_score = predict(userid, itemid, p, q)
        predict_score[itemid] = p_score
    return predict_score

#训练&测试实验
def recommend():
    print('start')
    user_items = {1: {'a': 1, 'b': -1, 'c': -1, 'd': -1, 'e': 1, 'f': 1, 'g': -1},
                  2: {'a': -1, 'b': 1, 'c': -1, 'd': 1, 'e': 1, 'f': 1, 'g': 1},
                  3: {'a': 1, 'b': -1, 'c': 0, 'd': -1, 'e': -1, 'f': -1, 'g': 1},
                  4: {'a': 1, 'b': -1, 'c': -1, 'd': 0, 'e': 1, 'f': 1, 'g': 1},
                  5: {'a': -1, 'b': 1, 'c': 1, 'd': 1, 'e': -1, 'f': -1, 'g': 0},
                  6: {'a': 1, 'b': 0, 'c': -1, 'd': -1, 'e': 1, 'f': -1, 'g': -1}}
    users = {1, 2, 3, 4, 5, 6}
    items = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}
    F = 5
    N = 30
    alpha = 0.3
    lamda = 0.03
    p, q = lfm(user_items, users, items, F, N, alpha, lamda)

    for userid, itemdic in user_items.items():
        print(userid)
        print("label：", itemdic)
        predict_score = predictlist(userid, itemdic, p, q)
        print("predicted：", predict_score)

    print('end')

if __name__ == "__main__":
    recommend()