推荐系统记录个人向-01

推荐系统协同过滤：

user-cf就是计算user-user矩阵和user-item矩阵，通过计算欧式距离或余弦相似度找寻相似度最高的用户，然后推荐该用户评分较高的item

item-cf就是计算item-item矩阵，矩阵值为同时喜欢item1和item2的用户数目，以此来找寻相似度最高的item

相似度计算

杰卡德相似系数，两个用户的交互商品交集占两个用户交互商品并集的比例
余弦相似度，两个用户交互商品交集占两个用户交互商品的乘积的比例
皮尔逊相关系数

实际情况使用pandas存储，用户对物品打分存在很多空值，表现为NaN，即矩阵很稀疏

user-cf缺陷，数据稀疏性，购买大件家电等低频应用很难找到偏好相似的用户，不适用于用户量大的情况。

item-cf这个更适用于兴趣变化较为稳定的应用， 更接近于个性化的推荐， 适合物品少，用户多，用户兴趣固定持久， 物品更新速度不是太快的场合， 比如推荐艺术品， 音乐， 电影。

评价指标：

MAE, HitRatio, Recall, Precision, Accuracy, F1

MAE计算预测用户评分与用户实际评分之间的偏差，一般和评分预测有关
HR常用于top-k推荐，
Recall、precision常用于top-k推荐

召回率recall，用户真实看过或评分的物品，模型真正预测出了多少
准确率accuracy，推荐的所有物品中有多少是用户真正看过或评分的

协同过滤缺陷：

泛化能力弱，热门商品具有很强的头部效应，容易跟大量物品相似，而尾部商品特征向量稀疏，很少被推荐，最终推荐系统头部效应明显

较差的稀疏向量处理能力

仅仅利用了用户与物品的交互信息就可以实现推荐，比较简单高效，但这也是它的一个短板所在，由于无法有效的引入用户年龄、性别、商品描述、商品分类、当前时间、地点等一系列用户特征、物品特征和上下文特征，这就造成了有效信息的遗漏，不能充分利用其它特征数据。

完全没有利用到物品本身或者是用户自身的属性

为了解决这个问题， 在推荐模型中引用更多的特征，推荐系统慢慢的从以协同过滤为核心到了以逻辑回归模型为核心， 提出了能够综合不同类型特征的机器学习模型。

在MovieLens数据集上简单实现了user-cf，主要是为了体验一下其思想。

import numpy as np
import pandas as pd
data = pd.read_csv(r"path\MovieLens\ml-latest-small\data.csv", nrows=10)
print(data)
ratings = pd.read_csv(r"path\MovieLens\ml-latest-small\ratings.csv")
movies = pd.read_csv(r"path\MovieLens\ml-latest-small\movies.csv")
ratings.head()

movies_list = movies['movieId'].tolist()
movies_dict1 = {}
movies_dict2 = {}
for i in range(len(movies_list)):
    movies_dict1[movies_list[i]] = i # movies_dict1  true_index
    movies_dict2[i] = movies_list[i] # movies_dict2  index

user_user = np.zeros([610+1, 610+1])
user_item = np.zeros([610+1, 9742])

for tup in ratings.itertuples():
    # tup: index userId movieId rating timestamp
    #      0     1      1       4.0    
    movieid = movies_dict1[tup[2]]
    user_item[tup[1]][movieid] = tup[3]

def edclidean(user1,user2):
    distance = 0
    for k in range(movie):
        if user_item[user1][k] != 0 and user_item[user2][k] != 0:
            distance += (float(user_item[user1][k])-float(user_item[user2][k])) ** 2
    return 1/(1+np.sqrt(distance))


user = 610 + 1
movie = 9742
for i in range(user):
    for j in range(user):
        if i == j:
            continue
        user_user[i][j] = edclidean(i, j)

index = []
for i in range(user):
    index.append(i)
print(index)

user_user_nd = np.array(user_user)
#print(user_user_nd.shape)

# user_index = 1
target = 1
#copy = user_user_nd[target]  #共享内存
copy = []
for i in range(user):
    copy.append(user_user[target][i])
print(copy)
for i in range(len(copy)):
    for j in range(len(copy)-1):
        if copy[j+1]<copy[j]:
            copy[j],copy[j+1] = copy[j+1],copy[j]
            index[j],index[j+1] = index[j+1],index[j]

print(index)

# 推荐user68看过的而user01没看过的
rs_list = []
for i in range(movie):
    if user_item[1][i] == 0 and user_item[68][i] != 0 :
        rs_list.append(movies_dict2[i])
        #print(user_item[68][i])

print(rs_list)
#for i in range(len(rs_list)):
#    print(user_item[68][rs_list[i]])

movie_name = movies["title"].tolist()
movie_list = []
for i in range(len(rs_list)):
    true_index = movies_dict1[rs_list[i]]
    movie_list.append(movie_name[true_index])

print(movie_list)

# user68看过的但user01没看过的，rating排序

rs_sort_index = rs_list # movie的原始id
rs_sort_value = []
print(len(rs_list))
for i in range(len(rs_list)):
    #print(rs_list[i])
    true_index = movies_dict1[rs_list[i]]
    #print(true_index)
    #rs_sort_value.append(user_item[68][i])
    rs_sort_value.append(user_item[68][true_index])
    

for i in range(len(rs_list)):
    for j in range(len(rs_list)-1):
        if rs_sort_value[j]<rs_sort_value[j+1]:
            temp = rs_sort_value[j]
            rs_sort_value[j] = rs_sort_value[j+1]
            rs_sort_value[j+1] = temp
            
            temp = rs_sort_index[j]
            rs_sort_index[j] = rs_sort_index[j+1]
            rs_sort_index[j+1] = temp

print(rs_sort_value)
print(rs_sort_index)



movie_name = movies["title"].tolist()
movie_list = []
for i in range(len(rs_sort_index)):
    true_index = movies_dict1[rs_list[i]]
    movie_list.append(movie_name[true_index])
print(movie_list)

# 计算出了user-user矩阵和user-item矩阵
# 通过排序可以对查找用户1相似度最高的用户2，并进行推荐
# 推荐时根据用户1没有而用户2有的movie进行推荐，推荐有全部推荐和用户2评分最高推荐(top-k)