LFM算法核心思想是通过隐含特征(latent factor)联系用户兴趣和物品，找出潜在的主题和分类。LFM（latent factor model）通过如下公式计算用户u对物品i的兴趣：
[Preference(u,i) = r_{ui} = {p_u}^T q_i = sum_{f=1}^F p_{u,k} q_{i,k}
]
定义(P)矩阵是user-class矩阵，矩阵值(P_{ij})表示的是user (i)对class (j)的兴趣度；(Q)矩阵式class-item矩阵，矩阵值(Q_{ij})表示的是item (j)在class (i)中的权重，权重越高越能作为该类的代表。那么，用户(U)对物品(I)的兴趣度为：
[R_{UI} = P_U Q_I = sum_{k=1}^K P_{U,K} Q_{K,I}
]
整个程序框架分为了train和test两个部分。
在训练中，初始化需要所有的user_id与item_id，然后指定初始化参数：主题数量(class_count)，迭代次数(iter_count)，学习率(lr)，正则项参数(lambd)。
之后调用了两个方法：
- _init_data
这里假设用户观看的电影评分3分以上为正样本，所以需要对其他电影采样作为负样本。self.items_dict存储了对于每一个用户而言的正样本和负样本字典。若为正，则value为1，否则，value为0。
实际上，对于评分数据而言，可以直接采用rating作为label，这里区分正负样本是为了更具普遍性。
- _init_model
初始化向量(p)和(q)后，使用LFM算法迭代计算。具体的：
[predict = sigmoid(sum P_{U,K} Q_{K,I})
]
令损失函数为：
[J = 1/2 * (y - predict)^2 + lambda ||p_u||^2 + lambda ||q_i||^2
]
根据梯度下降，可得：
[p_u = p_u - lr * [-(y - predict) * q_i + 2 lambda ||p_u||] \
q_i = q_i - lr * [-(y - predict) * p_u + 2 lambda ||q_i||]
]
全部代码如下所示：
#-*-coding:utf-8-*-
"""
author:jamest
date:20190306
LFM function
"""
import math
import pandas as pd
import random
import numpy as np
import pickle
class LFM:
def __init__(self, user_ids, item_ids):
self.class_count = 5
self.iter_count = 5
self.lr = 0.02
self.lambd = 0.01
self._init_data(user_ids, item_ids)
self._init_model()
# 下采样
def _randomSelectNegativeSample(self,user_id,user_ids,item_ids):
items = [x[1] for x in zip(user_ids,item_ids) if x[0]==user_id]
res = dict()
for i in items:
res[i] = 1
n = 0
for i in range(len(items) * 3):
item = item_ids[random.randint(0, len(item_ids) - 1)]
if item in res:
continue
res[item] = 0
n += 1
if n > len(items):
break
return res
def _get_dic(self,user_ids,item_ids):
items_dict = {}
for user_id in self.user_ids_set:
items_dict[user_id] = self._randomSelectNegativeSample(user_id,user_ids,item_ids)
return items_dict
def _init_data(self,user_ids,item_ids):
self.user_ids_set = set(user_ids)
self.item_ids_set = set(item_ids)
self.items_dict = self._get_dic(user_ids,item_ids)
def _init_model(self):
"""
Get corpus and initialize model params.
"""
array_p = np.random.randn(len(self.user_ids_set), self.class_count)
array_q = np.random.randn(len(self.item_ids_set), self.class_count)
self.p = pd.DataFrame(array_p, columns=range(0, self.class_count), index=list(self.user_ids_set))
self.q = pd.DataFrame(array_q, columns=range(0, self.class_count), index=list(self.item_ids_set))
def _predict(self, user_id, item_id):
"""
Calculate interest between user_id and item_id.
p is the look-up-table for user's interest of each class.
q means the probability of each item being classified as each class.
"""
p = np.mat(self.p.ix[user_id].values)
q = np.mat(self.q.ix[item_id].values).T
r = (p * q).sum()
# logit = 1.0 / (1 + math.exp(-r))
logit = self._sigmoid(r)
return logit
def _sigmoid(self,z):
return 1./(1 + np.exp(-z))
def _loss(self, user_id, item_id, y, step):
"""
Loss Function define as MSE, the code write here not that formula you think.
"""
e = y - self._predict(user_id, item_id)
print('Step: {}, user_id: {}, item_id: {}, y: {}, loss: {}'.
format(step, user_id, item_id, y, e))
return e
def _optimize(self, user_id, item_id, e):
"""
Use SGD as optimizer, with L2 p, q square regular.
e.g: E = 1/2 * (y - predict)^2, predict = matrix_p * matrix_q
derivation(E, p) = -matrix_q*(y - predict), derivation(E, q) = -matrix_p*(y - predict),
derivation（l2_square，p) = lam * p, derivation（l2_square, q) = lam * q
delta_p = lr * (derivation(E, p) + derivation（l2_square，p))
delta_q = lr * (derivation(E, q) + derivation（l2_square, q))
"""
gradient_p = -e * self.q.ix[item_id].values
l2_p = 2 * self.lambd * self.p.ix[user_id].values
delta_p = self.lr * (gradient_p + l2_p)
gradient_q = -e * self.p.ix[user_id].values
l2_q = 2 * self.lambd * self.q.ix[item_id].values
delta_q = self.lr * (gradient_q + l2_q)
self.p.loc[user_id] -= delta_p
self.q.loc[item_id] -= delta_q
def train(self):
for step in range(self.iter_count):
for user_id, item_dict in self.items_dict.items():
item_ids = list(item_dict.keys())
random.shuffle(item_ids)
for item_id in item_ids:
e = self._loss(user_id, item_id, item_dict[item_id], step)
self._optimize(user_id, item_id, e)
self.lr *= 0.9
self.save()
def predict(self, user_id, items,top_n=10):
"""
Calculate all item user have not meet before and return the top n interest items.
"""
self.load()
user_item_ids = set(items)
other_item_ids = self.item_ids_set ^ user_item_ids
interest_list = [self._predict(user_id, item_id) for item_id in other_item_ids]
candidates = sorted(zip(list(other_item_ids), interest_list), key=lambda x: x[1], reverse=True)
return candidates[:top_n]
def save(self):
"""
Save model params.
"""
f = open('../data/lfm.model', 'wb')
pickle.dump((self.p, self.q), f)
f.close()
def load(self):
"""
Load model params.
"""
f = open('../data/lfm.model', 'rb')
self.p, self.q = pickle.load(f)
f.close()
if __name__ == '__main__':
moviesPath = '../data/ml-1m/movies.dat'
ratingsPath = '../data/ml-1m/ratings.dat'
usersPath = '../data/ml-1m/users.dat'
ratingsDF = pd.read_csv(ratingsPath, index_col=None, sep='::', header=None,names=['user_id', 'movie_id', 'rating', 'timestamp'])
ratingsDF = ratingsDF[ratingsDF['rating']>3]
X=ratingsDF['user_id'][:1000]
Y=ratingsDF['movie_id'][:1000]
# LFM(X,Y).train()
items = ratingsDF[ratingsDF['user_id']==1]['movie_id'].values
rank = LFM(X,Y).predict(1,items)
print('LFM result',rank)