基於矩陣分解的協同過濾算法實現：FunkSVD（LFM）

日萌社

人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度學習實戰（不定時更新）

---

 

基於矩陣分解的CF算法實現（一）：LFM

LFM也就是前面提到的Funk SVD矩陣分解

LFM原理解析

LFM(latent factor model)隱語義模型核心思想是通過隱含特徵聯繫用戶和物品，如下圖：

• P矩陣是User-LF矩陣，即用戶和隱含特徵矩陣。LF有三個，表示共總有三個隱含特徵。
• Q矩陣是LF-Item矩陣，即隱含特徵和物品的矩陣
• R矩陣是User-Item矩陣，有P*Q得來
• 能處理稀疏評分矩陣

利用LFM預測用戶對物品的評分，k表示隱含特徵數量：

因此最終，我們的目標也就是要求出P矩陣和Q矩陣及其當中的每一個值，然後再對用戶-物品的評分進行預測。

算法實現

• 數據加載

import pandas as pd
import numpy as np
dtype = [("userId", np.int32), ("movieId", np.int32), ("rating", np.float32)]
dataset = pd.read_csv("ml-latest-small/ratings.csv", usecols=range(3), dtype=dict(dtype))

• 數據初始化

  tips 更多關於groupby的 API 詳見 http://pandas.pydata.org/pandas-docs/stable/reference/groupby.html

# 用戶評分數據  groupby 分組  groupby('userId') 根據用戶id分組 agg（aggregation聚合）
users_ratings = dataset.groupby('userId').agg([list])
# 物品評分數據
items_ratings = dataset.groupby('movieId').agg([list])
# 計算全局平均分
global_mean = dataset['rating'].mean()
# 初始化P Q  610  9700   K值  610*K    9700*K
# User-LF  10 代表 隱含因子個數是10個
P = dict(zip(users_ratings.index,np.random.rand(len(users_ratings),10).astype(np.float32)
        ))
# Item-LF
Q = dict(zip(items_ratings.index,np.random.rand(len(items_ratings),10).astype(np.float32)
        ))

• 梯度下降優化損失函數

#梯度下降優化損失函數
for i in range(15):
    print('*'*10,i)
    for uid,iid,real_rating in dataset.itertuples(index = False):
        #遍歷 用戶 物品的評分數據 通過用戶的id 到用戶矩陣中獲取用戶向量
        v_puk = P[uid]
        # 通過物品的uid 到物品矩陣裏獲取物品向量
        v_qik = Q[iid]
        #計算損失
        error = real_rating-np.dot(v_puk,v_qik)
        # 0.02學習率 0.01正則化係數
        v_puk += 0.02*(error*v_qik-0.01*v_puk)
        v_qik += 0.02*(error*v_puk-0.01*v_qik)

        P[uid] = v_puk
        Q[iid] = v_qik

• 評分預測

def predict(self, uid, iid):
    # 如果uid或iid不在，我們使用全劇平均分作爲預測結果返回
    if uid not in self.users_ratings.index or iid not in self.items_ratings.index:
        return self.globalMean
    p_u = self.P[uid]
    q_i = self.Q[iid]

    return np.dot(p_u, q_i)

'''
LFM Model
'''
import pandas as pd
import numpy as np

# 評分預測    1-5
class LFM(object):

    def __init__(self, alpha, reg_p, reg_q, number_LatentFactors=10, number_epochs=10, columns=["uid", "iid", "rating"]):
        self.alpha = alpha # 學習率
        self.reg_p = reg_p    # P矩陣正則
        self.reg_q = reg_q    # Q矩陣正則
        self.number_LatentFactors = number_LatentFactors  # 隱式類別數量
        self.number_epochs = number_epochs    # 最大迭代次數
        self.columns = columns

    def fit(self, dataset):
        '''
        fit dataset
        :param dataset: uid, iid, rating
        :return:
        '''

        self.dataset = pd.DataFrame(dataset)

        self.users_ratings = dataset.groupby(self.columns[0]).agg([list])[[self.columns[1], self.columns[2]]]
        self.items_ratings = dataset.groupby(self.columns[1]).agg([list])[[self.columns[0], self.columns[2]]]

        self.globalMean = self.dataset[self.columns[2]].mean()

        self.P, self.Q = self.sgd()

    def _init_matrix(self):
        '''
        初始化P和Q矩陣，同時爲設置0，1之間的隨機值作爲初始值
        :return:
        '''
        # User-LF
        P = dict(zip(
            self.users_ratings.index,
            np.random.rand(len(self.users_ratings), self.number_LatentFactors).astype(np.float32)
        ))
        # Item-LF
        Q = dict(zip(
            self.items_ratings.index,
            np.random.rand(len(self.items_ratings), self.number_LatentFactors).astype(np.float32)
        ))
        return P, Q

    def sgd(self):
        '''
        使用隨機梯度下降，優化結果
        :return:
        '''
        P, Q = self._init_matrix()

        for i in range(self.number_epochs):
            print("iter%d"%i)
            error_list = []
            for uid, iid, r_ui in self.dataset.itertuples(index=False):
                # User-LF P
                ## Item-LF Q
                v_pu = P[uid] #用戶向量
                v_qi = Q[iid] #物品向量
                err = np.float32(r_ui - np.dot(v_pu, v_qi))

                v_pu += self.alpha * (err * v_qi - self.reg_p * v_pu)
                v_qi += self.alpha * (err * v_pu - self.reg_q * v_qi)

                P[uid] = v_pu 
                Q[iid] = v_qi

                # for k in range(self.number_of_LatentFactors):
                #     v_pu[k] += self.alpha*(err*v_qi[k] - self.reg_p*v_pu[k])
                #     v_qi[k] += self.alpha*(err*v_pu[k] - self.reg_q*v_qi[k])

                error_list.append(err ** 2)
            print(np.sqrt(np.mean(error_list)))
        return P, Q

    def predict(self, uid, iid):
        # 如果uid或iid不在，我們使用全劇平均分作爲預測結果返回
        if uid not in self.users_ratings.index or iid not in self.items_ratings.index:
            return self.globalMean

        p_u = self.P[uid]
        q_i = self.Q[iid]

        return np.dot(p_u, q_i)

    def test(self,testset):
        '''預測測試集數據'''
        for uid, iid, real_rating in testset.itertuples(index=False):
            try:
                pred_rating = self.predict(uid, iid)
            except Exception as e:
                print(e)
            else:
                yield uid, iid, real_rating, pred_rating

if __name__ == '__main__':
    dtype = [("userId", np.int32), ("movieId", np.int32), ("rating", np.float32)]
    dataset = pd.read_csv("datasets/ml-latest-small/ratings.csv", usecols=range(3), dtype=dict(dtype))

    lfm = LFM(0.02, 0.01, 0.01, 10, 100, ["userId", "movieId", "rating"])
    lfm.fit(dataset)

    while True:
        uid = input("uid: ")
        iid = input("iid: ")
        print(lfm.predict(int(uid), int(iid)))