LFM 隐语义模型

隐语义模型：

物品       表示为长度为k的向量q（每个分量都表示  物品具有某个特征的程度）

用户兴趣 表示为长度为k的向量p（每个分量都表示  用户对某个特征的喜好程度）

用户u对物品i的兴趣可以表示为

　　

其损失函数定义为-

      

使用随机梯度下降，获得参数p,q

 

负样本生成：

对于只有正反馈信息（用户收藏了，关注了xxx）的数据集，需要生成负样本，原则如下

1.生成的负样本要和正样本数量相当

2.物品越热门（用户没有收藏该物品），越有可能是负样本

 

实现：

# coding=gbk
'''
实现隐语义模型，对隐式数据进行推荐
1.对正样本生成负样本
  -负样本数量相当于正样本
  -物品越热门，越有可能成为负样本
2.使用随机梯度下降法，更新参数
'''

import numpy as np
import pandas as pd
import random
from sklearn import cross_validation

class LFM():
    
    '''
    初始化隐语义模型
    参数：
    *F  隐特征的个数
    *N  迭代次数
    *data 训练数据,要求为pandas的dataframe
    *alpha 随机梯度下降的学习速率
    *r 正则化参数
    *ratio 负样本/正样本比例
    '''
    def __init__(self,data,F=100,N=1000,alpha=0.02,r=0.01,ratio=1):
        self.F=F
        self.N=N
        self.alpha=alpha
        self.r=r
        self.data=data
        self.ratio=ratio
    
    '''
    初始化物品池，物品池中物品出现的次数与其流行度成正比
    '''    
    def InitItemPool(self):
        self.itemPool=[]
        groups = self.data.groupby([1])
        for item,group in groups:
            for i in range(group.shape[0]):
                self.itemPool.append(item)
    
    '''
    获取每个用户对应的商品（用户购买过的商品）列表，如
    {用户1:[商品A，商品B，商品C],
     用户2:[商品D，商品E，商品F]...}
    ''' 
    def user_item(self,data):
        ui = dict()
        groups = data.groupby([0])
        for item,group in groups:
            ui[item]=set(group.ix[:,1])
        
        return ui
    
    '''
    初始化隐特征对应的参数
    numpy的array存储参数，使用dict存储每个用户（物品）对应的列
    '''
    def initParam(self):
        users=set(self.data.ix[:,0])
        items=set(self.data.ix[:,1])
        
        self.Pdict=dict()
        self.Qdict=dict()
        for user in users:
            self.Pdict[user]=len(self.Pdict)
        
        for item in items:
            self.Qdict[item]=len(self.Qdict)
        
        self.P=np.random.rand(self.F,len(users))/10
        self.Q=np.random.rand(self.F,len(items))/10
    
    '''
    使用随机梯度下降法，更新参数
    '''
    def stochasticGradientDecent(self):
        alpha=self.alpha
        for i in range(self.N):
            for user,items in self.ui.items():
                ret=self.RandSelectNegativeSamples(items)
                for item,rui in ret.items():
                   p=self.P[:,self.Pdict[user]]
                   q=self.Q[:,self.Qdict[item]]
                   eui=rui-sum(p*q)
                   tmp=p+alpha*(eui*q-self.r*p)
                   self.Q[:,self.Qdict[item]]+=alpha*(eui*p-self.r*q)
                   self.P[:,self.Pdict[user]]=tmp
            alpha*=0.9
            print i
            
    def Train(self):
        self.InitItemPool()
        self.ui = self.user_item(self.data)
        self.initParam()
        self.stochasticGradientDecent()
    
    def Recommend(self,user,k):
        items=self.ui[user]
        p=self.P[:,self.Pdict[user]]
        
        rank = dict()
        for item,id in self.Qdict.items():
            if item in items:
                continue
            q=self.Q[:,id];
            rank[item]=sum(p*q)
        return sorted(rank.items(),lambda x,y:cmp(x[1],y[1]),reverse=True)[0:k-1];
    '''
    生成负样本
    '''
    def RandSelectNegativeSamples(self,items):
        ret=dict()
        for item in items:
            #所有正样本评分为1
            ret[item]=1
        #负样本个数，四舍五入
        negtiveNum = int(round(len(items)*self.ratio))
        
        N = 0
        while N<negtiveNum:
            item = self.itemPool[random.randint(0, len(self.itemPool) - 1)]
            if item in items:
                #如果在用户已经喜欢的物品列表中，继续选
                continue
            N+=1
            #负样本评分为0
            ret[item]=0
        return ret

data=pd.read_csv('../data/ratings.dat',sep='::',nrows=10000,header=None)
data=data.ix[:,0:1]

train,test=cross_validation.train_test_split(data,test_size=0.2)
train = pd.DataFrame(train)
test = pd.DataFrame(test)

lfm = LFM(data=train)
lfm.Train()
lfm.Recommend(1, 10)