推薦系統surprise庫官方文檔解讀

• 安裝時常見問題
• Surprise的功能
• 示例
• • 使用內置的數據集+交叉驗證
  • 不使用交叉驗證，只把數據集分割一次
  • 使用自己的數據集、不使用測試集
  • 自行指定訓練集和測試集
• 內置算法和參數設置
• • NormalPredictor算法
  • • • 示例代碼
  • Baseline算法
  • • ALS
    • • 示例代碼
    • SGD
    • • 示例代碼
  • KNNBasic算法
  • • • 示例代碼
  • KNNWithMeans算法
  • • • 示例代碼
  • KNNWithZScore算法
  • • • 示例代碼
  • KNNBaseline算法
  • • • 示例代碼
  • SVD算法
  • • • 示例代碼
  • SVDpp算法
  • • • 示例代碼
  • NMF算法
  • • • 示例代碼
  • SlopeOne算法
  • • • 示例代碼
  • CoClustering算法
• Precision、Recall、MAP和NDCG的計算

安裝時常見問題

安裝還是常見的

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庫非常適用于初學者了解推薦算法，其內置的功能包括：

內部實現了部分基礎的推薦算法：KNN類算法（最基礎的KNN算法、考慮了均值的KNNWithMeans、考慮了標準值的KNNWithZSore和考慮了baseline的KNNBaseline）、SVD類算法（SVD算法、SVDpp算法和NMF算法）、SlopeOne算法和co-clustering算法；

自動的多折交叉驗證，如5折交叉驗證；但同時也可以滿足其他的設置，如將自行分割的訓練集和測試集輸入模型；

自動計算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

$re{g}_i$：使用ALS得到非精確解的分母上的衰減因子${\lambda }_i$，默認為10

$re{g}_u$：使用ALS得到非精確解的分母上的衰減因子${\lambda }_u$，默認為15

$n\_epochs$：ALS的迭代次數，默認為10

$verbose$：是否輸出訓練的信息，默認為True，即輸出，基本每個算法都有這個參數，后面的算法介紹時不再說明此參數

示例代碼

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

SGD

$reg$：正則化率，默認為0.02

$learning\_rate$：學習速率，默認為0.005

$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)?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)?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)?(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)?(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)?(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)?(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)?(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)?(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}?q_i?\lambda p_u)$$
$$q_i\leftarrow q_i+\gamma (e_{ui}?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?p_u+|I_u{|}^{?\frac{1}{2}}\sum _{j\in I_u}{y}_j?$$
和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})$$

$n\_cltr\_u$：用戶類的數量，默認為3

$n\_cltr\_i$：項目類的數量，默認為3

$n\_epochs$：迭代次數，默認為20

$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 mathnum_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 = 0score = 0.0dcg = 0.0dic = {}m = 0for i in range(len(testset)):if int(testset[i][0]) not in dic:dic[int(testset[i][0])] = mm += 1ls = []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.0ap_score = 0.0ap = 0.0cg = 0.0for y in range(topk):if sor[i][y] in real[i]:ap_score += 1ap += 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 / idcgrecall += ap_score / (len(real[i]) * fenmu)precision += ap_score / (topk * fenmu)map += float(score) / fenmundcg += float(dcg) / fenmu print 'precision ' + str(precision) print 'recall ' + str(recall) print 'map ' + str(map) print 'ndcg ' + str(ndcg)

總結

以上是生活随笔為你收集整理的推荐系统surprise库教程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。