推荐系统surprise库教程

安装时常见问题

安装还是常见的

pip install surprise

安装常见问题：出现报错（error: Microsoft Visual C++ 14.0 is required. Get it with “Microsoft Visual C++ Build Tools”: https://visualstudio.microsoft.com/downloads/）
解决方法：
①最笨的方法，下载所提示的对应的Visual Studio版本；
②核心思想，躲！在https://www.lfd.uci.edu/~gohlke/pythonlibs/上找到对应python版本的想要的库的whl包，然后pip install xx.whl进行安装，surprise库的shl文件在https://pypi.org/project/surprise/#files，不过可能还是躲不掉；
③对于2.7选手，可以在https://www.microsoft.com/en-us/download/details.aspx?id=44266上下载VCForPython27.msi以支持对用C写成的包的支持；

Surprise的功能

Surprise库非常适用于初学者了解推荐算法，其内置的功能包括：

1. 内部实现了部分基础的推荐算法：KNN类算法（最基础的KNN算法、考虑了均值的KNNWithMeans、考虑了标准值的KNNWithZSore和考虑了baseline的KNNBaseline）、SVD类算法（SVD算法、SVDpp算法和NMF算法）、SlopeOne算法和co-clustering算法；
2. 自动的多折交叉验证，如5折交叉验证；但同时也可以满足其他的设置，如将自行分割的训练集和测试集输入模型；
3. 自动计算RMSE、MAE、MSE和FCP（Precision、Recall、F1-score、MAP和NDCG等指标没有内置，但可以根据输出自行编写，后文会给出，供参考）。

示例

本节会给出Surprise库使用的相关示例，读者可以根据自己的需要对示例的代码进行改写，从而实现自己所需的功能。

使用内置的数据集+交叉验证

from surprise import SVD
from surprise import Dataset
from surprise.model_selection import cross_validate
# 加载内置的ml100k数据集
data = Dataset.load_builtin('ml-100k')
# 使用SVD算法
algo = SVD()
# 使用五折交叉验证，使用cv参数设置几折，measures设置评价指标，verbose设置为True表示显示详细信息
cross_validate(algo, data, measures=['RMSE', 'MAE'], cv=5, verbose=True)

不使用交叉验证，只把数据集分割一次

写成类似于sklearn中的常见写法

from surprise import SVD
from surprise import Dataset
from surprise import accuracy
from surprise.model_selection import train_test_split
data = Dataset.load_builtin('ml-100k')
# 类似于sklearn中的写法，将数据分割为75%
trainset, testset = train_test_split(data, test_size=.25)
algo = SVD()
# 不同上一个例子，这里使用fit和test函数
algo.fit(trainset)
predictions = algo.test(testset)
# 选用rmse指标
accuracy.rmse(predictions)

使用自己的数据集、不使用测试集

from surprise import SVD
from surprise import Dataset
from surprise import accuracy
from surprise import Reader
# 指定要读入的文件的格式，本例中每行三列，分别是用户、项目和评分，中间用空格隔开，若是用逗号或其他符号隔开，在sep参数中进行变化即可
reader = Reader(line_format='user item rating', sep=' ')
# 指定要读入的数据文件，本例中为test.txt
data = Dataset.load_from_file('test.txt', reader=reader)
# 把全部数据集都作为训练集
data = data.build_full_trainset()
algo = SVD()
algo.fit(trainset)
predictions = algo.test(testset)
accuracy.rmse(predictions)

自行指定训练集和测试集

from surprise import SVD
from surprise import Dataset
from surprise import accuracy
from surprise import Reader
from surprise.model_selection import PredefinedKFold
# 数据集在系统路径\data\下
files_dir = os.path.expanduser('~/data/')
# 训练集为u1.base、u2.base
train_file = files_dir + 'u%d.base'
# 测试集为u1.test、u2.test
test_file = files_dir + 'u%d.test'
# range(m,n)表示训练集和测试集文件的命名，因为本例中是从u1到u2，所以这里为range(1,3)，其实就是定义一个列表，里面是一组组训练集和测试集文件，即[(训练集1，测试集1)，（训练集2，测试集2）……]
folds_files = [(train_file % i, test_file % i) for i in range(1, 3)]
reader = Reader(line_format='user item rating', sep='\t')
data = Dataset.load_from_folds(folds_files, reader=reader)
pkf = PredefinedKFold()
algo = SVD()
# 因为本例中有两组训练集和测试集，所以出现两次结果
for trainset, testset in pkf.split(data):
    algo.fit(trainset)
    predictions = algo.test(testset)
    accuracy.rmse(predictions, verbose=True)
    accuracy.mae(predictions, verbose=True)

内置算法和参数设置

NormalPredictor算法

该算法即随机预测算法，假设测试集的评分满足正态分布，然后生成正态分布的随机数进行预测，正态分布$N(\hat{\mu },{\hat{\sigma }}^2)$的参数均值和方差从训练集中得到。
$$\hat{\mu }=\frac{1}{|R_{train}|}\sum _{r_{ui}\in R_{train}}{r}_{ui}$$
$$\hat{\sigma }=\sqrt{\sum _{r_{ui}\in R_{train}}\frac{(r_{ui}-\hat{\mu }{)}^2}{|R_{train}|}}$$

示例代码

algo = NormalPredictor()

Baseline算法

Koren提出的baseline算法，不考虑用户的偏好
$$\widehat{r_{ui}}=\mu +b_u+b_i$$
对于未在训练集中出现的$u$，$b_u=0$（$b_i$做类似处理）
参数设置
训练方法是使用交替最小二乘法（ALS）还是随机梯度下降（SGD）

ALS

1. $re{g}_i$：使用ALS得到非精确解的分母上的衰减因子${\lambda }_i$，默认为10
2. $re{g}_u$：使用ALS得到非精确解的分母上的衰减因子${\lambda }_u$，默认为15
3. $n\_epochs$：ALS的迭代次数，默认为10
4. $verbose$：是否输出训练的信息，默认为True，即输出，基本每个算法都有这个参数，后面的算法介绍时不再说明此参数

示例代码

bsl_options = {'method': 'als',
               'n_epochs': 5,
               'reg_u': 12,
               'reg_i': 5
               }
algo = BaselineOnly(bsl_options=bsl_options)

SGD

5. $reg$：正则化率，默认为0.02
6. $learning\_rate$：学习速率，默认为0.005
7. $n\_epochs$：ALS的迭代次数，默认为20

示例代码

bsl_options = {'method': 'sgd',
               'learning_rate': .00005,
               }
algo = BaselineOnly(bsl_options=bsl_options)

KNNBasic算法

最基础的KNN算法，可分为user-based KNN和item-based KNN
user-based KNN的公式
$$\widehat{r_{ui}}=\frac{{\sum }_{v\in N_i^k(u)}sim(u,v)\cdot r_{vi}}{{\sum }_{v\in N_i^k(u)}sim(u,v)}$$
item-based KNN的公式
$$\widehat{r_{ui}}=\frac{{\sum }_{j\in N_u^k(i)}sim(i,j)\cdot r_{uj}}{{\sum }_{j\in N_u^k(i)}sim(i,j)}$$
8. $k$：设置的邻居的个数，默认为40
9. $min\_k$：最少的邻居的个数，如果合适的邻居达不到设置的最小邻居值，则使用全局平均值进行预测，默认为1
10. $sim\_options$中的$name$：使用的计算相似度的函数，默认为MSD，也可设置为cosine或pearson_baseline
11. $sim\_options$中的$user\_based$：默认为True，即使用user-based KNN，若设置为True，则使用item-based KNN
12. $sim\_options$中的$min\_support$：相似度达到该值，才能进入邻居的选择范围，无默认值
13. $sim\_options$中的$shrinkage$：当相似函数选择为pearson_baseline，用该参数设置是否衰减，默认为100

示例代码

sim_options = {'name': 'cosine',
               'user_based': False  # compute  similarities between items
               }
algo = KNNBasic(k=10, sim_options=sim_options)

sim_options = {'name': 'pearson_baseline',
               'shrinkage': 0  # no shrinkage
               }
algo = KNNBasic(k=10, sim_options=sim_options)

KNNWithMeans算法

在KNNBasic算法的基础上，考虑用户均值或项目均值
$${\hat{r}}_{ui}={\mu }_u+\frac{\sum _{v\in N_i^k(u)}\text{sim}(u,v)\cdot (r_{vi}-{\mu }_v)}{\sum _{v\in N_i^k(u)}\text{sim}(u,v)}$$
或
$${\hat{r}}_{ui}={\mu }_i+\frac{\sum _{j\in N_u^k(i)}\text{sim}(i,j)\cdot (r_{uj}-{\mu }_j)}{\sum _{j\in N_u^k(i)}\text{sim}(i,j)}$$
参数设置与KNNBasic类似

示例代码

sim_options = {'name': 'cosine',
               'user_based': False  # compute  similarities between items
               }
algo = KNNWithMeans(k=10, sim_options=sim_options)

KNNWithZScore算法

引入Z-Score的思想
$${\hat{r}}_{ui}={\mu }_u+{\sigma }_u\frac{\sum _{v\in N_i^k(u)}\text{sim}(u,v)\cdot (r_{vi}-{\mu }_v)/{\sigma }_v}{\sum _{v\in N_i^k(u)}\text{sim}(u,v)}$$
或
$${\hat{r}}_{ui}={\mu }_i+{\sigma }_i\frac{\sum _{j\in N_u^k(i)}\text{sim}(i,j)\cdot (r_{uj}-{\mu }_j)/{\sigma }_j}{\sum _{j\in N_u^k(i)}\text{sim}(i,j)}$$
参数设置与KNNBasic类似

示例代码

sim_options = {'name': 'cosine',
               'user_based': False  # compute  similarities between items
               }
algo = KNNWithZScore(k=10, sim_options=sim_options)

KNNBaseline算法

和KNNWithMeans的区别在于，用的不是均值而是bias
$${\hat{r}}_{ui}=b_{ui}+\frac{\sum _{v\in N_i^k(u)}\text{sim}(u,v)\cdot (r_{vi}-b_{vi})}{\sum _{v\in N_i^k(u)}\text{sim}(u,v)}$$
或
$${\hat{r}}_{ui}=b_{ui}+\frac{\sum _{j\in N_u^k(i)}\text{sim}(i,j)\cdot (r_{uj}-b_{uj})}{\sum _{j\in N_u^k(i)}\text{sim}(i,j)}$$
参数设置与KNNBasic类似

示例代码

sim_options = {'name': 'cosine',
               'user_based': False  # compute  similarities between items
               }
algo = KNNBaseline(k=10, sim_options=sim_options)

SVD算法

经典的SVD算法
$${\hat{r}}_{ui}=\mu +b_u+b_i+q_i^T{p}_u$$
损失函数为
$$\sum _{r_{ui}\in R_{train}}{\left(r_{ui}-{\hat{r}}_{ui}\right)}^2+\lambda \left(b_i^2+b_u^2+||q_i|{|}^2+||p_u|{|}^2\right)$$
优化公式为
$$b_u\leftarrow b_u+\gamma (e_{ui}-\lambda b_u)$$
$$b_i\leftarrow b_i+\gamma (e_{ui}-\lambda b_i)$$
$$p_u\leftarrow p_u+\gamma (e_{ui}\cdot q_i-\lambda p_u)$$
$$q_i\leftarrow q_i+\gamma (e_{ui}\cdot p_u-\lambda q_i)$$
14. $n\_factors$：隐因子的数量，默认为100
15. $n\_epochs$：迭代次数，默认为20
16. $biased$：默认为True，即使用SGD，如果为False，则使用MF算法也就是PMF算法
17. $init\_mean$：p和q两个向量的初始值由正态分布生成，均值参数由该参数设置，默认为0
18. $init\_std\_dev$：p和q两个向量的初始值由正态分布生成，标准差参数由该参数设置，默认为0.1
19. $lr\_all$：可由该参数直接设置所有学习速率的值，默认为0.005
20. $reg\_all$：可由该参数直接设置所有正则化系数的值，默认为0.02
21. $lr\_bu$：设置$b_u$的学习速率，可覆盖$lr\_all$，默认未设置
22. $lr\_bi$：设置$b_i$的学习速率，可覆盖$lr\_all$，默认未设置
23. $lr\_pu$：设置$p_u$的学习速率，可覆盖$lr\_all$，默认未设置
24. $lr\_qi$：设置$q_i$的学习速率，可覆盖$lr\_all$，默认未设置
25. $reg\_bu$：设置$b_u$的学习速率，可覆盖$reg\_all$，默认未设置
26. $reg\_bi$：设置$b_i$的学习速率，可覆盖$reg\_all$，默认未设置
27. $reg\_pu$：设置$p_u$的学习速率，可覆盖$reg\_all$，默认未设置
28. $reg\_qi$：设置$q_i$的学习速率，可覆盖$reg\_all$，默认未设置
29. $random\_state$：随机种子设置，默认未设置，可设置为一个整数，即可在多次试验时得到相同结果（在相同的训练集和测试集的情况下）

示例代码

algo = SVD(n_factors=5, n_epochs=20, lr_all=0.007, reg_all=0.002, verbose=False, init_mean=0.1, init_std_dev=0)

SVDpp算法

依然是Koren提出的，考虑了隐性反馈的SVDpp算法
$${\hat{r}}_{ui}=\mu +b_u+b_i+q_i^T\left(p_u+|I_u{|}^{-\frac{1}{2}}\sum _{j\in I_u}{y}_j\right)$$
和SVD相比，多了两个参数
30. $lr\_yj$：设置$y_j$的学习速率，可覆盖$lr\_all$，默认未设置
31. $reg\_yj$：设置$y_j$的学习速率，可覆盖$reg\_all$，默认未设置

示例代码

algo = SVDpp(n_factors=5, n_epochs=20, lr_all=0.007, reg_all=0.002, verbose=False, init_mean=0.1, init_std_dev=0)

NMF算法

非负矩阵分解，即要求p矩阵和q矩阵都是正的
$${\hat{r}}_{ui}=q_i^T{p}_u,$$
和SVD相比，多了两个参数
32. $init\_low$：设置初始值的下限，默认为0
33. $init\_high$：设置初始值的上限，默认为1

示例代码

algo = NMF(n_factors=5, n_epochs=20, lr_all=0.007, reg_all=0.002, verbose=False, init_mean=0.1, init_std_dev=0)

SlopeOne算法

$${\hat{r}}_{ui}={\mu }_u+\frac{1}{|R_i(u)|}\sum _{j\in R_i(u)}\text{dev}(i,j)$$
$$\text{dev}(i,j)=\frac{1}{|U_{ij}|}\sum _{u\in U_{ij}}{r}_{ui}-r_{uj}$$

示例代码

algo = SlopeOne()

CoClustering算法

$${\hat{r}}_{ui}=\overline{C_{ui}}+({\mu }_u-\overline{C_u})+({\mu }_i-\overline{C_i})$$

1. $n\_cltr\_u$：用户类的数量，默认为3
2. $n\_cltr\_i$：项目类的数量，默认为3
3. $n\_epochs$：迭代次数，默认为20
4. $random\_state$：随机种子设置，默认未设置，可设置为一个整数，即可在多次试验时得到相同结果（在相同的训练集和测试集的情况下）

Precision、Recall、MAP和NDCG的计算

#!/usr/bin/python
# -*- coding: utf-8 -*-
from surprise import KNNBasic
from surprise import Dataset
import pandas as pd
from surprise import Reader
import numpy as np
from surprise.model_selection import KFold
import math

num_item = 80
reader = Reader(line_format='user item rating', sep=',')
data = Dataset.load_from_file('rating2.txt', reader=reader)
kf = KFold(n_splits=5)
sim_options = {'name': 'cosine',
               'user_based': False
               }
algo = KNNBasic(sim_options=sim_options, verbose=False)
precision = 0.0
recall = 0.0
map = 0.0
ndcg = 0.0
topk = 3
for trainset, testset in kf.split(data):
    algo.fit(trainset)
    fenmu = pd.DataFrame(np.array(testset)[:, 0]).drop_duplicates().shape[0]
    real = [[] for i in range(fenmu)]
    sor = [[] for i in range(fenmu)]
    hit = 0
    score = 0.0
    dcg = 0.0
    dic = {}
    m = 0
    for i in range(len(testset)):
        if int(testset[i][0]) not in dic:
            dic[int(testset[i][0])] = m
            m += 1
            ls = []
            real[m - 1].append(int(testset[i][1]))
            for j in range(num_item):
                uid = str(testset[i][0])
                iid = str(j)
                pred = algo.predict(uid, iid)
                ls.append([pred[3], j])
            ls = sorted(ls, key=lambda x: x[0], reverse=True)
            for s in range(topk):
                sor[m-1].append(int(ls[s][1]))
        else:
            real[dic[int(testset[i][0])]].append(int(testset[i][1]))
    for i in range(fenmu):
        idcg = 0.0
        ap_score = 0.0
        ap = 0.0
        cg = 0.0
        for y in range(topk):
            if sor[i][y] in real[i]:
                ap_score += 1
                ap += ap_score / (y + 1)
                cg += 1 / math.log((y + 2), 2)
        score += ap / min(len(real[i]), topk)
        for z in range(int(ap_score)):
            idcg += 1 / math.log((z + 2), 2)
        if idcg > 0:
            dcg += cg / idcg
        recall += ap_score / (len(real[i]) * fenmu)
        precision += ap_score / (topk * fenmu)
    map += float(score) / fenmu
    ndcg += float(dcg) / fenmu
print 'precision ' + str(precision / 5.0)
print 'recall ' + str(recall / 5.0)
print 'map ' + str(map / 5.0)
print 'ndcg ' + str(ndcg / 5.0)