一、简介：

推荐系统是最常见的数据分析应用之一，包含淘宝、豆瓣、今日头条都是利用推荐系统来推荐用户内容。推荐算法的方式分为两种，一种是根据用户推荐，一种是根据商品推荐，根据用户推荐主要是找出和这个用户兴趣相近的其他用户，再推荐其他用户也喜欢的东西给这个用户，而根据商品推荐则是根据喜欢这个商品的人也喜欢哪些商品区进行推荐，现在很多是基于这两种算法去进行混合应用。本文会用python演示第一种算法，目标是对用户推荐电影。

二、获取数据：

在movielens上，有许多的用户对电影评价数据，可以至（https://grouplens.org/datasets/movielens/）进行下载，下载完后打开资料夹，有个叫u.data的资料夹，打开会看到以下的数据

第一列代表用户ID，第二列代表电影的ID，第三列代表评分（1-5分），第四列是时间戳

三、数据预处理

拿到了原始数据后，我们会发现几个问题，就是1、我根本不需要时间戳。2、同一个用户的评价散落在不连续好几行，不好进行分析。这个时候我们就需要进行数据的预处理，首先观察这份数据发现由于每个用户评价的电影都不相同，可能在200部里随机挑了5-10部来评分，所以如果用表格来显示的话会有很多的空格，这个时候KV型数据储存方式就很好用，利用一个键（key）对应一个值（value），这个时候就可以利用python的字典（dict），他可以记录键值对应。举例来说，我用户ID为"941’的用户，对电影ID为"763’的评价是3分，那我只需要储存【941】【763】=3这样就可以了，并把user合并，让界面更美观，如下图

可以看到我把用户ID为"941’评价的电影都列了出来，后面还跟了评分值，这样我后面在做分析的时候读取数据就比较方便了，下面是数据读取到处理的代码

defload_data():

f= open('u.data')

user_list={}for line inf:

(user,movie,rating,ts)= line.split(' ')

user_list.setdefault(user,{})

user_list[user][movie]=float(rating)return user_list

user_list就是我们建立用来分析的名单

三、算法：

这边是使用最简单的欧几里得距离算法，简单来说就是将两人对同一部电影的评价相减平方再开根号，比如A看了蝙蝠侠给了5分，B看了给了5分，但C看了给分，AB距离是0， AC距离是2，可以得知A和B的喜好比较相近，当然现在推荐系统算法很多，这边只是挑了一个比较简单的算法，下面是算法的代码

defcalculate():

list=load_data()

user_diff={}for movies in list['7']:for people inlist.keys():

user_diff.setdefault(people,{})for item inlist[people].keys():if item ==movies:

diff= sqrt(pow(list['7'][movies] - list[people][item],2))

user_diff[people][item]=diffreturn user_diff

这边挑了其中一位ID为7的用户，我的任务是帮他找出他可能会感兴趣的电影，所以先计算所有用户跟7的距离，由于7跟其他用户都看了不同的电影，所以要先找出共同看过的电影再将所有电影的距离列出来。

接下来再把所有电影的距离取平均值，由于我们想知道的是相似度，相似度与平均值成反比，所以我们将距离倒过来就是相似度，另外为了让相似度这个数介于0~1，所以用了1/（1+距离）这个算法，以下为代码

defpeople_rating():

user_diff=calculate()

rating={}for people inuser_diff.keys():

rating.setdefault(people,{})

a=0

b=0for score inuser_diff[people].values():

a+=score

b+=1rating[people]= float(1/(1+(a/b)))return rating

可以看到虽然代码有点丑，不过还是可以跑出个结果，下面就是结果，可以看到跟所有用户的相似度，可以看到跟ID为12的用户相似度为0.58， 跟ID为258的用户相似度为0.333

现在就是要从这里面找出几个相似度比较高的用户，也很简单，利用sort排个序，再选出前五个，下面为代码

deftop_list():

list=people_rating()

items=list.items()

top= [[v[1],v[0]] for v initems]

top.sort(reverse=True)print(top[0:5])

下面为结果

可以看到第一名就是他自己，然后547和384也和他非常契合，不过45名的相似度就下降的非常的快，现在我们来检视547跟384的菜单吧

我们先来验证一下547跟384跟我们7号用户的相似度为什么这么高，下面代码可以找出547跟7号用户共同看过的电影跟评分

list =load_data()for k,v in list['7'].items():for kk,vv in list['547'].items():if k ==kk:print(k,v,kk,vv)

跑出来的结果如下

原来他们只共同看了三部电影，给的评分还一样，所以距离才为0

再用同样方法来看384跟7号

可以看到他们也是刚好看了3部一样的电影，给的分数也是一样，有趣的事他们三个都看了ID为258的电影，也都给了4分

接下来就是最后一步了，我们要找出547和384看过但7号没看过的电影，再从里面找出评分高的推荐给7号，下面为代码

deffind_rec():

rec_list=top_list()

first= rec_list[1][1]

second= rec_list[2][1]

all_list=load_data()for k,v inall_list[first].items():if k not in all_list['7'].keys() and v == 5:print(k)for k,v inall_list[second].items():if k not in all_list['7'].keys() and v == 5:print (k)

最后跑出来的结果为

以上为547跟384的推荐名单，可以看到316/302/313都是两人共同推荐，代表这三部片应该是很好看，所以如果要推荐给7号用户的话可以选择这三片来推荐。

四、总结

在演练的过程里面我们可以看出这个算法的许多缺点，例如最高分的其实是因为他们共同看过的电影少，分数又刚好相同，很难说明这就是有共同的兴趣，然后相似度的落差太大，前两名都是1,三四名就掉到了0.75，可见三四名应该是与7号共同看过4部电影，但有其中一部的评分差了一分，导致分数骤降，而大部分的用户都集中在0.3-0,5之间，分数曲线极度不平滑。虽然有这些缺点，但这些算出来的推荐结果还是有代表了一定的意义，至少可以代表是与7号用户品味相似的人给出的高分电影，而7号尚未给过评分。

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、运行结果

作者专业长期研究各种协同过滤推荐算法，欢迎留言、私信互相交流学习，后续会不断更新不同的协同过滤推荐算法，欢迎关注。

前言

首先简单介绍粒子群优化算法，粒子群优化算法的python实现（含代码）

一、粒子群优化算法是什么？

粒子群优化算法(Particle Swarm Optimization, PSO)作为进化计算的一个分支，是由Eberhart和Kennedy于1995年提出的一种全局搜索算法，同时它也是一种模拟自然界的生物活动以及群体智能的随即搜索算法。
粒子群优化算法起源于鸟群觅食的过程，一个核心机制是每只小鸟各自觅食，并记住一个离食物最近的位置，通过和其他的小鸟交流，得到整个鸟群已知的最佳位置，引导鸟群朝着这个方向继续搜索。
还有两个关键设置：粒子历史最优位置(pBest向量)、群体历史最优位置(gBest向量)。
这里pBest向量是一组向量，它包含了每个粒子的历史最优位置，gBest向量为pBest向量中适应值最高的向量，即全局最优。
说明：算法中一般取要优化的目标函数作为适应值函数，评估适应值的大小，然后更新pBest向量和gBest向量。

二、算法流程

（1）初始化所有个体（粒子），初始化它们的速度和位置，并且将个体的历史最优位置pBest设为当前位置，而群体中最优的个体作为当前的gBest。
（2）在每一代的进化中，计算各个粒子的适应度函数值。
（3）如果该粒子当前的适应度函数值比其历史最优值要好，那么历史最优将会被当前位置所代替。
（4）如果该粒子的历史最优比全局最优要好，那么全局最优将会被该粒子的历史最优所替代。
（5）对每个粒子i的第d维的速度和位置分别按照下列公式进行更新。这两个公式在二维空间中的关系如下图。



ω是惯量权重，一般初始化为0.9，随着迭代过程线性递减到0.4 ; c₁和c₂是加速系数(也称学习因子)，传统上取固定值2.0 ; rand₁^d是和rand₂^d是两个[0,1]之间的随机数。另外，设置一个V_max限制速度的范围，V_max的每一维V_max^d一般取相应维的取值范围的10%~20%。更新后检查位置是否在问题空间内。
这里ω做一个线性递减是因为，在算法一开始，群体没有一个方向做指导，所以需要一个任意性，进行搜索；而随着算法的迭代，群体已经有了一个指导方向，就不再需要很大的任意性，而是受个体历史最优和群体历史最优的影响越来越大。
（6）如果还没有到达结束条件，转到（2），否则输出gBest并结束。
下图为算法的流程图。

三、算法的python实现

本算法以优化目标函数：

为例，使用粒子群优化算法进行求解。
运行环境：python3.6，jupyter notebook

# 目标函数值计算
def f(C):
    return 1/(C[0]**2+C[1]**2+C[2]**2+C[3]**2+1)
# 初始化种群 C=[[[x],[v]]]
def init(N):
    C = np.zeros((N,2,4))
    global pBest,gBest
    for i in range(N):
        for j in range(4):
            C[i][0][j] = np.random.uniform(-5,5)
            C[i][1][j] = np.random.uniform(-1,1)
        pBest[i] = C[i][0]
    gBest = pBest[np.argmax(Eval(C,N))].copy()
    return C
# 判断更新后是否还在问题空间内
def whether_out(C):
    for i in range(len(C)):
        for j in range(4):
            if C[i][0][j] < -5 :
                C[i][0][j] = -5
            elif C[i][0][j] > 5:
                C[i][0][j] = 5
    return C

# 更新粒子的速度和位置
def update_C(C,N,w,c1,c2):
    '''
    C:种群 [[[x],[v]]]
    N:种群规模 100
    w:惯量权重 初始0.9，递减到0.4
    c1、c2:加速系数
    pBest: 每个粒子的历史最优位置[[x]]
    gBest: 全局最优位置[x]
    '''
#     print(C.shape)
    for i in range(N):
        for j in range(4):
            rand1 = np.random.random()
            rand2 = np.random.random()
            C[i][1][j] = w*C[i][1][j]+c1*rand1*(pBest[i][j]-C[i][0][j])+c2*rand2*(gBest[j]-C[i][0][j])
            C[i][0][j] +=  C[i][1][j]
    C = whether_out(C)
    return C
        
# 评估函数
def Eval(C,N):
    temp = np.array([])
    for i in range(N):
        temp = np.append(temp,f(C[i][0]))
    return temp
# 更新粒子的历史最优和全局最优
def update_best(C,N,fitness):
    '''
    pBest: 每个粒子的历史最优位置,[[x]]
    gBest: 全局最优位置,[x]
    fitness: 粒子当前适应值,[f(x)]
    '''
    global pBest,gBest
    for i in range(N):
        if fitness[i] > f(pBest[i]):
            pBest[i] = C[i][0]
        if fitness[i] > f(gBest):
            gBest = C[i][0].copy()
# w线性递减
def w_degression(w,N):
    w -= 0.5/N
    return w

def PSO(length,N,w,c1,c2):
    global pBest,gBest
    C = init(N)
#     print('gBest:',gBest)
    for i in range(length):
        C = update_C(C,N,w,c1,c2)
        fitness = Eval(C,N)
        update_best(C,N,fitness)
        w=w_degression(w,N)
        if f(gBest)==1.0:
            break
    return [f(gBest),gBest,i]

start = time.time()
c1,c2 = 2,2
# length:迭代次数，N:种群规模
length,N=1000,30
w=0.9
pBest = np.zeros((N,4))
gBest = np.zeros(N)
# PSO(length,N,w,c1,c2)
end = time.time()
print(PSO(length,N,w,c1,c2))
print('PSO运行时间: %.2f s'%(end-start))

实验结果

当种群数设置为100时

当种群数设置为30时