经典的SVD算法，预测评分的的计算公式如下：
 
 
 
其中μ为评分的平均值，分别表示u用户的偏置量和i物品的偏置量。
 
从而，要优化的式子是如下形式：
 
 
 
要通过梯度下降优化的变量为四个，如下：
 

 
 
参考了一些代码，现在使用python实现如下
 

import numpy as np
import random


class SVD:
    def __init__(self,mat,K=20):
        self.mat=np.array(mat)
        self.K=K
        self.bi={}
        self.bu={}
        self.qi={}
        self.pu={}
        self.avg=np.mean(self.mat[:,2])
        for i in range(self.mat.shape[0]):
            uid=self.mat[i,0]
            iid=self.mat[i,1]
            self.bi.setdefault(iid,0)
            self.bu.setdefault(uid,0)
            self.qi.setdefault(iid,np.random.random((self.K,1))/10*np.sqrt(self.K))
            self.pu.setdefault(uid,np.random.random((self.K,1))/10*np.sqrt(self.K))
    def predict(self,uid,iid):  #预测评分的函数
        #setdefault的作用是当该用户或者物品未出现过时，新建它的bi,bu,qi,pu，并设置初始值为0
        self.bi.setdefault(iid,0)
        self.bu.setdefault(uid,0)
        self.qi.setdefault(iid,np.zeros((self.K,1)))
        self.pu.setdefault(uid,np.zeros((self.K,1)))
        rating=self.avg+self.bi[iid]+self.bu[uid]+np.sum(self.qi[iid]*self.pu[uid]) #预测评分公式
        #由于评分范围在1到5，所以当分数大于5或小于1时，返回5,1.
        if rating>5:
            rating=5
        if rating<1:
            rating=1
        return rating
    
    def train(self,steps=30,gamma=0.04,Lambda=0.15):    #训练函数，step为迭代次数。
        print('train data size',self.mat.shape)
        for step in range(steps):
            print('step',step+1,'is running')
            KK=np.random.permutation(self.mat.shape[0]) #随机梯度下降算法，kk为对矩阵进行随机洗牌
            rmse=0.0
            for i in range(self.mat.shape[0]):
                j=KK[i]
                uid=self.mat[j,0]
                iid=self.mat[j,1]
                rating=self.mat[j,2]
                eui=rating-self.predict(uid, iid)
                rmse+=eui**2
                self.bu[uid]+=gamma*(eui-Lambda*self.bu[uid])  
                self.bi[iid]+=gamma*(eui-Lambda*self.bi[iid])
                tmp=self.qi[iid]
                self.qi[iid]+=gamma*(eui*self.pu[uid]-Lambda*self.qi[iid])
                self.pu[uid]+=gamma*(eui*tmp-Lambda*self.pu[uid])
            gamma=0.93*gamma
            print('rmse is',np.sqrt(rmse/self.mat.shape[0]))
    
    def test(self,test_data):  #gamma以0.93的学习率递减
        
        test_data=np.array(test_data)
        print('test data size',test_data.shape)
        rmse=0.0
        for i in range(test_data.shape[0]):
            uid=test_data[i,0]
            iid=test_data[i,1]
            rating=test_data[i,2]
            eui=rating-self.predict(uid, iid)
            rmse+=eui**2
        print('rmse of test data is',np.sqrt(rmse/test_data.shape[0]))
            
            
def getData():   #获取训练集和测试集的函数
    import re
    f=open('C:/Users/xuwei/Desktop/data.txt','r')
    lines=f.readlines()
    f.close()
    data=[]
    for line in lines:
        list=re.split('\t|\n',line)
        if int(list[2]) !=0:    #提出评分0的数据，这部分是用户评论了但是没有评分的
            data.append([int(i) for i in list[:3]])
    random.shuffle(data)
    train_data=data[:int(len(data)*7/10)]
    test_data=data[int(len(data)*7/10):]
    print('load data finished')
    print('total data ',len(data))
    return train_data,test_data
    
   

train_data,test_data=getData()
a=SVD(train_data,30)  
a.train()
a.test(test_data)
        
                 
            

 

 
 

 
 
 
使用了自己爬取的豆瓣约130万的评分信息进行测试，分为测试组和训练组，训练组数据取70%，测试组占30%。
 
下面是测试结果：
 

 
 
最后训练集的RMSE为0.485，测试集0.654.
 

 
 
 
 

 

 

python实现基于用户的协同过滤推荐算法和基于项目的协同过滤推荐算法
 
基于用户的协同过滤推荐算法和基于项目的协同过滤推荐算法实现原理、公式、思路在前文中已有介绍，本次不再详细描述。本文主要是使用python语言实现推荐算法，python语言有很多工具模块便于实现推荐算法，本文没有大量使用已有的机器学习模块，更多的是使用python的基础语法实现，注释详细，代码阅读性好，便于学习。
 
python版本3.8，movielens数据集，943个用户，1682部电影，8万条评分数据。
 
一、项目目录
 
 
二、基于用户的协同过滤推荐算法
 
1、算法原理：构建用户项目评分矩阵、计算用户之间的相似度、得到目标用户的最近邻居、预测评分、推荐
 2、读取评分数据，构建用户-项目评分矩阵
 3、用户-项目评分矩阵模块
 
 这个模块是保存用户项目评分数据，同时分析数据，打印输出分析结果
 4、计算用户之间的相似度模块
 
 这个模块是计算用户之间的相似度，调用了余弦算法相似度模块
 5、得到目标用户的最近邻居模块
 
 这个模块是相似度排序，找到前N个相似度最大的用户，也可以设置相似度阀值来判定最近邻居
 6、预测评分、推荐模块
 
 7、测评指标MAE模块
 
 8、运行结果
 
 
 
 
 
 
二、基于项目的协同过滤推荐算法
 
1、算法原理：构建用户项目评分矩阵、计算项目之间的相似度、预测评分、推荐
 2、计算项目之间的相似度模块
 
 3、预测评分、推荐模块
 
 4、运行结果
 
 
 
 
作者专业长期研究各种协同过滤推荐算法，欢迎留言、私信互相交流学习，后续会不断更新不同的协同过滤推荐算法，欢迎关注。

工具包
 
在GitHub上找到一个开源的项目，并对其进行了更新，提交了一些小bug，它实现了数学建模中常用的算法包括：
 
差分进化算法
遗传算法
粒子群算法
模拟退火算法
蚁群算法
免疫优化算法
人工鱼群算法
 
项目链接：
 https://github.com/zhangxiao123qqq/scikit-opt
 原作者链接：
 https://github.com/guofei9987/scikit-opt
 
黑盒实现，即拿即用！不要太爽！！
 
提示：项目中使用等help()命令可直接获得参数说明。
 
#遗传算法帮助
help(GA)
#模拟退火算法帮助
help(SA)
 
算法使用方式见：
 
中文使用文档
 
Demo演示:
 
 demo_ga
 
import numpy as np


def schaffer(p):
    '''
    This function has plenty of local minimum, with strong shocks
    global minimum at (0,0) with value 0
    '''
    x1, x2 = p
    x = np.square(x1) + np.square(x2)
    return 0.5 + (np.square(np.sin(x)) - 0.5) / np.square(1 + 0.001 * x)


# %%
from sko.GA import GA

ga = GA(func=schaffer, n_dim=2, size_pop=50, max_iter=800, lb=[-1, -1], ub=[1, 1], precision=1e-7)
best_x, best_y = ga.run()
print('best_x:', best_x, '\n', 'best_y:', best_y)

# %% Plot the result
import pandas as pd
import matplotlib.pyplot as plt

Y_history = pd.DataFrame(ga.all_history_Y)
fig, ax = plt.subplots(2, 1)
ax[0].plot(Y_history.index, Y_history.values, '.', color='red')
Y_history.min(axis=1).cummin().plot(kind='line')
plt.show()

一、背景 
 关于推荐算法的相关背景介绍，已经在上一个姊妹篇（三）协同过滤算法之基于物品的推荐算法python实现中有所介绍。在此，便不在赘述，本文主要介绍基于用户的协同过滤算法，而对推荐算法不太清楚的朋友们可以参考上一篇基于物品的过滤算法的相关介绍，参考地址如下：https://blog.csdn.net/wickedvalley/article/details/79927699。
 
二、生活应用
 
推荐算法应用比较广，常见的就是推荐电影了，上一篇是基于物品的推荐算法，主要是根据物品的相似度来进行推荐。本文的推荐算法是基于用户的推荐，原理也是类似的，主要是计算出与当前需要推荐用户的最相似用户，从而根据最相似的用户喜欢的物品来推荐当前可能喜欢的物品。 
 还是以电影推荐为例子，见下图： 
 
 
说明： 
 三个用户分别为A用户、B用户、C用户。他们看过的电影如上图所示，他们看过的电影中，既有相同的，也有不同的。我们需要计算与待推荐的用户A与所有的用户的相似度，进而找到与A用户最相似的N个用户，假设N=1，则需要找到与A用户最相思的1个用户，如上图，可以找到B用户与A用户是最相似的，从而将B看过而A没有看过的《机器猫》推荐给A用户。
 
四、相似度计算 
 相似度的计算有欧式距离、皮尔逊相关系数等，本文主要介绍皮尔逊相关系数。
 
Pearson相关系数用来衡量两个数据集合之间的相似性。比如在一个关于电影的资料网站中，很多用户都可能对其中的电影进行打分。Pearson相关系数可以用来帮助更好的找到兴趣相似的用户，从而进行相关的推荐。这种推荐的基本思路是如果A和B兴趣相似，那么A喜欢看的，B就有很大可能会喜欢看，就可以把A的喜欢看的推荐给B。
 
假设电影库中5部电影，A和B都对其中的部分进行了打分（5分为满分），A的分数是[3, 2, -, 1, 4]，B的分数是[5, 3, 3, -, 5]，其中“-”表示未打分。那么A和B的Pearson相关系数是0.866，说明两个人的兴趣是比较相似的。
 
Pearson相关系数的一个优点是可以避免评分等级膨胀（grade inflation）的问题，也就是说有的用户可能倾向于对所有的电影都给比较高的分数，而有的用户则会比较苛刻，给分都比较低。对于这种情况，Pearson相关系数可以处理。
 
Pearson相关系数的具体计算公式为： 
 
 
五、算法流程：
 
1.根据当前用户，计算与当前用户最相似的N个用户； 
 2.推荐这N个最相似的用户看过的电影（排除当前用户观看过的） 
 3.将所有当前用户没有看过的电影，按照评分从高到低推荐给用户
 
六、python实现算法
 
1.数据描述 
 数据为用户，以及用户观看的电影，评分。
 
如下：用户Lisa Rose 看过的电影以及相应的评分为’Lady in the Water’: 2.5，’Snakes on a Plane’: 3.5 …..
 
  users = {'Lisa Rose': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,
                           'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5,
                           'The Night Listener': 3.0},

             'Gene Seymour': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5,
                              'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0,
                              'You, Me and Dupree': 3.5},

             'Michael Phillips': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0,
                                  'Superman Returns': 3.5, 'The Night Listener': 4.0},

             'Claudia Puig': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0,
                              'The Night Listener': 4.5, 'Superman Returns': 4.0,
                              'You, Me and Dupree': 2.5},

             'Mick LaSalle': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,
                              'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0,
                              'You, Me and Dupree': 2.0},

             'Jack Matthews': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,
                               'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5},

             'Toby': {'Snakes on a Plane': 4.5, 'You, Me and Dupree': 1.0, 'Superman Returns': 4.0}
             }
 
2.目标 
 给用户Toby推荐可能感兴趣的电影
 
3.算法实现
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
'''
基于用户的推荐算法
'''
from math import sqrt,pow
import operator
class UserCf():

    #获得初始化数据
    def __init__(self,data):
        self.data=data;

    #通过用户名获得电影列表，仅调试使用
    def getItems(self,username1,username2):
        return self.data[username1],self.data[username2]

    #计算两个用户的皮尔逊相关系数
    def pearson(self,user1,user2):#数据格式为：电影，评分  {'Snakes on a Plane': 4.5, 'You, Me and Dupree': 1.0, 'Superman Returns': 4.0}
        sumXY=0.0;
        n=0;
        sumX=0.0;
        sumY=0.0;
        sumX2=0.0;
        sumY2=0.0;
        try:
            for movie1,score1 in user1.items():
                if movie1 in user2.keys():#计算公共的电影的评分
                    n+=1;
                    sumXY+=score1*user2[movie1]
                    sumX+=score1;
                    sumY+=user2[movie1]
                    sumX2+=pow(score1,2)
                    sumY2+=pow(user2[movie1],2)

            molecule=sumXY-(sumX*sumY)/n;
            denominator=sqrt((sumX2-pow(sumX,2)/n)*(sumY2-pow(sumY,2)/n))
            r=molecule/denominator
        except Exception,e:
            print "异常信息:",e.message
            return None
        return r

    #计算与当前用户的距离，获得最临近的用户
    def nearstUser(self,username,n=1):
        distances={};#用户，相似度
        for otherUser,items in self.data.items():#遍历整个数据集
            if otherUser not in username:#非当前的用户
                distance=self.pearson(self.data[username],self.data[otherUser])#计算两个用户的相似度
                distances[otherUser]=distance
        sortedDistance=sorted(distances.items(),key=operator.itemgetter(1),reverse=True);#最相似的N个用户
        print "排序后的用户为：",sortedDistance
        return sortedDistance[:n]


    #给用户推荐电影
    def recomand(self,username,n=1):
        recommand={};#待推荐的电影
        for user,score in dict(self.nearstUser(username,n)).items():#最相近的n个用户
            print "推荐的用户：",(user,score)
            for movies,scores in self.data[user].items():#推荐的用户的电影列表
                if movies not in self.data[username].keys():#当前username没有看过
                    print "%s为该用户推荐的电影：%s"%(user,movies)
                    if movies not in recommand.keys():#添加到推荐列表中
                        recommand[movies]=scores

        return sorted(recommand.items(),key=operator.itemgetter(1),reverse=True);#对推荐的结果按照电影评分排序

if __name__=='__main__':
    users = {'Lisa Rose': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,
                           'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5,
                           'The Night Listener': 3.0},

             'Gene Seymour': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5,
                              'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0,
                              'You, Me and Dupree': 3.5},

             'Michael Phillips': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0,
                                  'Superman Returns': 3.5, 'The Night Listener': 4.0},

             'Claudia Puig': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0,
                              'The Night Listener': 4.5, 'Superman Returns': 4.0,
                              'You, Me and Dupree': 2.5},

             'Mick LaSalle': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,
                              'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0,
                              'You, Me and Dupree': 2.0},

             'Jack Matthews': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0,
                               'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5},

             'Toby': {'Snakes on a Plane': 4.5, 'You, Me and Dupree': 1.0, 'Superman Returns': 4.0}
             }

    userCf=UserCf(data=users)
    recommandList=userCf.recomand('Toby', 2)
    print "最终推荐：%s"%recommandList
 
4.算法结果
 
排序后的用户为： [('Lisa Rose', 0.9912407071619299), ('Mick LaSalle', 0.9244734516419049), ('Claudia Puig', 0.8934051474415647), ('Jack Matthews', 0.66284898035987), ('Gene Seymour', 0.38124642583151164), ('Michael Phillips', -1.0)]

推荐的用户： ('Lisa Rose', 0.9912407071619299)
Lisa Rose为该用户推荐的电影：Lady in the Water
Lisa Rose为该用户推荐的电影：Just My Luck
Lisa Rose为该用户推荐的电影：The Night Listener

推荐的用户： ('Mick LaSalle', 0.9244734516419049)
Mick LaSalle为该用户推荐的电影：Lady in the Water
Mick LaSalle为该用户推荐的电影：Just My Luck
Mick LaSalle为该用户推荐的电影：The Night Listener

最终推荐：[('Just My Luck', 3.0), ('The Night Listener', 3.0), ('Lady in the Water', 2.5)]