02 推荐算法-(01) Model-Based 协同过滤算法

Model-Based 协同过滤算法

随着机器学习技术的逐渐发展与完善，推荐系统也逐渐运用机器学习的思想来进行推荐。将机器学习应用到推荐系统中的方案真是不胜枚举。以下对Model-Based CF算法做一个大致的分类：

• 基于分类算法、回归算法、聚类算法
• 基于矩阵分解的推荐
• 基于神经网络算法
• 基于图模型算法

接下来我们重点学习以下几种应用较多的方案：

• 基于K最近邻的协同过滤推荐
• 基于回归模型的协同过滤推荐
• 基于矩阵分解的协同过滤推荐

基于K最近邻的协同过滤推荐

基于K最近邻的协同过滤推荐其实本质上就是MemoryBased CF，只不过在选取近邻的时候，加上K最近邻的限制。

这里我们直接根据MemoryBased CF的代码实现

修改以下地方

class CollaborativeFiltering(object):

    based = None

    def __init__(self, k=40, rules=None, use_cache=False, standard=None):
        '''
        :param k: 取K个最近邻来进行预测
        :param rules: 过滤规则，四选一，否则将抛异常："unhot", "rated", ["unhot","rated"], None
        :param use_cache: 相似度计算结果是否开启缓存
        :param standard: 评分标准化方法，None表示不使用、mean表示均值中心化、zscore表示Z-Score标准化
        '''
        self.k = 40
        self.rules = rules
        self.use_cache = use_cache
        self.standard = standard

修改所有的选取近邻的地方的代码，根据相似度来选取K个最近邻

similar_users = self.similar[uid].drop([uid]).dropna().sort_values(ascending=False)[:self.k]

similar_items = self.similar[iid].drop([iid]).dropna().sort_values(ascending=False)[:self.k]

但由于我们的原始数据较少，这里我们的KNN方法的效果会比纯粹的MemoryBasedCF要差

基于回归模型的协同过滤推荐

如果我们将评分看作是一个连续的值而不是离散的值，那么就可以借助线性回归思想来预测目标用户对某物品的评分。其中一种实现策略被称为Baseline（基准预测）。

Baseline：基准预测

Baseline设计思想基于以下的假设：

• 有些用户的评分普遍高于其他用户，有些用户的评分普遍低于其他用户。比如有些用户天生愿意给别人好评，心慈手软，比较好说话，而有的人就比较苛刻，总是评分不超过3分（5分满分）
• 一些物品的评分普遍高于其他物品，一些物品的评分普遍低于其他物品。比如一些物品一被生产便决定了它的地位，有的比较受人们欢迎，有的则被人嫌弃。

这个用户或物品普遍高于或低于平均值的差值，我们称为偏置(bias)

Baseline目标：

• 找出每个用户普遍高于或低于他人的偏置值 $b_u$
• 找出每件物品普遍高于或低于其他物品的偏置值 $b_i$
• 我们的目标也就转化为寻找最优的 $b_u$ 和 $b_i$

使用Baseline的算法思想预测评分的步骤如下：

• 计算所有电影的平均评分$\mu$（即全局平均评分）

• 计算每个用户评分与平均评分 $\mu$ 的偏置值 $b_u$

• 计算每部电影所接受的评分与平均评分$\mu$的偏置值 $b_i$

• 预测用户对电影的评分：
  $${\hat{r}}_{ui}=b_{ui}=\mu +b_u+b_i$$

举例：
比如我们想通过Baseline来预测用户A对电影“阿甘正传”的评分，那么首先计算出整个评分数据集的平均评分$\mu$是3.5分；而用户A是一个比较苛刻的用户，他的评分比较严格，普遍比平均评分低0.5分，即用户A的偏置值 $b_i$ 是-0.5；而电影“阿甘正传”是一部比较热门而且备受好评的电影，它的评分普遍比平均评分要高1.2分，那么电影“阿甘正传”的偏置值 $b_i$ 是+1.2，因此就可以预测出用户A对电影“阿甘正传”的评分为：$3.5+(-0.5)+1.2$，也就是4.2分。

对于所有电影的平均评分 $\mu$ 是直接能计算出的，因此问题在于要测出每个用户的 $b_u$ 值和每部电影的 $b_i$ 的值。

对于线性回归问题，我们可以利用平方差构建损失函数如下：
$$\begin{array}{rl}Cost& =\sum _{u,i\in R}(r_{ui}-{\hat{r}}_{ui}{)}^2\\ & =\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i{)}^2\end{array}$$

加入L2正则化：
$$Cost=\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i{)}^2+\lambda \ast (\sum _u{b_u}^2+\sum _i{b_i}^2)$$
公式解析：

• 公式第一部分 $ \sum_{u,i\in R}(r_{ui}-\mu-b_u-b_i)^2$ 是用来寻找与已知评分数据拟合最好的$b_u$和$b_i$
• 公式第二部分 $\lambda \ast ({\sum }_u{b_u}^2+{\sum }_i{b_i}^2)$ 是正则化项，用于避免过拟合现象

对于最小过程的求解，我们一般采用随机梯度下降法或者交替最小二乘法来优化实现。

方法一：随机梯度下降法优化

使用随机梯度下降优化算法预测Baseline偏置值

step 1：梯度下降法推导

损失函数

$$\begin{array}{rl}& J(\theta )=Cost=f(b_u,b_i)\\ & \\ & J(\theta )=\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i{)}^2+\lambda \ast (\sum _u{b_u}^2+\sum _i{b_i}^2)\end{array}$$

梯度下降参数更新原始公式

$${\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J(\theta )$$

梯度下降更新 $b_u$

损失函数偏导推导：

$$\begin{array}{rl}\frac{\partial }{\partial b_u}J(\theta )& =\frac{\partial }{\partial b_u}f(b_u,b_i)\\ & =2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i)(-1)+2\lambda b_u\\ & =-2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i)+2\lambda \ast b_u\end{array}$$

$b_u$更新(因为alpha可以人为控制，所以2可以省略掉)：

$$\begin{array}{rl}{b}_u& :=b_u-\alpha \ast (-\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i)+\lambda \ast b_u)\\ & :=b_u+\alpha \ast (\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i)-\lambda \ast b_u)\end{array}$$

同理可得，梯度下降更新 $b_i$:
$$b_i:=b_i+\alpha \ast (\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i)-\lambda \ast b_i)$$

step 2：随机梯度下降

由于随机梯度下降法本质上利用每个样本的损失来更新参数，而不用每次求出全部的损失和，因此使用SGD时：

单样本损失值：
$$\begin{array}{rl}error& =r_{ui}-{\hat{r}}_{ui}\\ & =r_{ui}-(\mu +b_u+b_i)\\ & =r_{ui}-\mu -b_u-b_i\end{array}$$
参数更新：
$$\begin{array}{rl}{b}_u& :=b_u+\alpha \ast ((r_{ui}-\mu -b_u-b_i)-\lambda \ast b_u)\\ & :=b_u+\alpha \ast (error-\lambda \ast b_u)\\ & \\ b_i& :=b_i+\alpha \ast ((r_{ui}-\mu -b_u-b_i)-\lambda \ast b_i)\\ & :=b_i+\alpha \ast (error-\lambda \ast b_i)\end{array}$$

step 3：算法实现

import pandas as pd
import numpy as np


class BaselineCFBySGD(object):

    def __init__(self, number_epochs, alpha, reg, columns=["uid", "iid", "rating"]):
        # 梯度下降最高迭代次数
        self.number_epochs = number_epochs
        # 学习率
        self.alpha = alpha
        # 正则参数
        self.reg = reg
        # 数据集中user-item-rating字段的名称
        self.columns = columns

    def fit(self, dataset):
        '''
        :param dataset: uid, iid, rating
        :return:
        '''
        self.dataset = 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.global_mean = self.dataset[self.columns[2]].mean()
        # 调用sgd方法训练模型参数
        self.bu, self.bi = self.sgd()

    def sgd(self):
        '''
        利用随机梯度下降，优化bu，bi的值
        :return: bu, bi
        '''
        # 初始化bu、bi的值，全部设为0
        bu = dict(zip(self.users_ratings.index, np.zeros(len(self.users_ratings))))
        bi = dict(zip(self.items_ratings.index, np.zeros(len(self.items_ratings))))

        for i in range(self.number_epochs):
            print("iter%d" % i)
            for uid, iid, real_rating in self.dataset.itertuples(index=False):
                error = real_rating - (self.global_mean + bu[uid] + bi[iid])

                bu[uid] += self.alpha * (error - self.reg * bu[uid])
                bi[iid] += self.alpha * (error - self.reg * bi[iid])

        return bu, bi

    def predict(self, uid, iid):
        predict_rating = self.global_mean + self.bu[uid] + self.bi[iid]
        return predict_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))

    bcf = BaselineCFBySGD(20, 0.1, 0.1, ["userId", "movieId", "rating"])
    bcf.fit(dataset)

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

Step 4: 准确性指标评估

添加test方法，然后使用之前实现accuary方法计算准确性指标

import pandas as pd
import numpy as np

def data_split(data_path, x=0.8, random=False):
    '''
    切分数据集， 这里为了保证用户数量保持不变，将每个用户的评分数据按比例进行拆分
    :param data_path: 数据集路径
    :param x: 训练集的比例，如x=0.8，则0.2是测试集
    :param random: 是否随机切分，默认False
    :return: 用户-物品评分矩阵
    '''
    print("开始切分数据集...")
    # 设置要加载的数据字段的类型
    dtype = {"userId": np.int32, "movieId": np.int32, "rating": np.float32}
    # 加载数据，我们只用前三列数据，分别是用户ID，电影ID，已经用户对电影的对应评分
    ratings = pd.read_csv(data_path, dtype=dtype, usecols=range(3))

    testset_index = []
    # 为了保证每个用户在测试集和训练集都有数据，因此按userId聚合
    for uid in ratings.groupby("userId").any().index:
        user_rating_data = ratings.where(ratings["userId"]==uid).dropna()
        if random:
            # 因为不可变类型不能被 shuffle方法作用，所以需要强行转换为列表
            index = list(user_rating_data.index)
            np.random.shuffle(index)    # 打乱列表
            _index = round(len(user_rating_data) * x)
            testset_index += list(index[_index:])
        else:
            # 将每个用户的x比例的数据作为训练集，剩余的作为测试集
            index = round(len(user_rating_data) * x)
            testset_index += list(user_rating_data.index.values[index:])

    testset = ratings.loc[testset_index]
    trainset = ratings.drop(testset_index)
    print("完成数据集切分...")
    return trainset, testset

def accuray(predict_results, method="all"):
    '''
    准确性指标计算方法
    :param predict_results: 预测结果，类型为容器，每个元素是一个包含uid,iid,real_rating,pred_rating的序列
    :param method: 指标方法，类型为字符串，rmse或mae，否则返回两者rmse和mae
    :return:
    '''

    def rmse(predict_results):
        '''
        rmse评估指标
        :param predict_results:
        :return: rmse
        '''
        length = 0
        _rmse_sum = 0
        for uid, iid, real_rating, pred_rating in predict_results:
            length += 1
            _rmse_sum += (pred_rating - real_rating) ** 2
        return round(np.sqrt(_rmse_sum / length), 4)

    def mae(predict_results):
        '''
        mae评估指标
        :param predict_results:
        :return: mae
        '''
        length = 0
        _mae_sum = 0
        for uid, iid, real_rating, pred_rating in predict_results:
            length += 1
            _mae_sum += abs(pred_rating - real_rating)
        return round(_mae_sum / length, 4)

    def rmse_mae(predict_results):
        '''
        rmse和mae评估指标
        :param predict_results:
        :return: rmse, mae
        '''
        length = 0
        _rmse_sum = 0
        _mae_sum = 0
        for uid, iid, real_rating, pred_rating in predict_results:
            length += 1
            _rmse_sum += (pred_rating - real_rating) ** 2
            _mae_sum += abs(pred_rating - real_rating)
        return round(np.sqrt(_rmse_sum / length), 4), round(_mae_sum / length, 4)

    if method.lower() == "rmse":
        rmse(predict_results)
    elif method.lower() == "mae":
        mae(predict_results)
    else:
        return rmse_mae(predict_results)

class BaselineCFBySGD(object):

    def __init__(self, number_epochs, alpha, reg, columns=["uid", "iid", "rating"]):
        # 梯度下降最高迭代次数
        self.number_epochs = number_epochs
        # 学习率
        self.alpha = alpha
        # 正则参数
        self.reg = reg
        # 数据集中user-item-rating字段的名称
        self.columns = columns

    def fit(self, dataset):
        '''
        :param dataset: uid, iid, rating
        :return:
        '''
        self.dataset = 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.global_mean = self.dataset[self.columns[2]].mean()
        # 调用sgd方法训练模型参数
        self.bu, self.bi = self.sgd()

    def sgd(self):
        '''
        利用随机梯度下降，优化bu，bi的值
        :return: bu, bi
        '''
        # 初始化bu、bi的值，全部设为0
        bu = dict(zip(self.users_ratings.index, np.zeros(len(self.users_ratings))))
        bi = dict(zip(self.items_ratings.index, np.zeros(len(self.items_ratings))))

        for i in range(self.number_epochs):
            print("iter%d" % i)
            for uid, iid, real_rating in self.dataset.itertuples(index=False):
                error = real_rating - (self.global_mean + bu[uid] + bi[iid])

                bu[uid] += self.alpha * (error - self.reg * bu[uid])
                bi[iid] += self.alpha * (error - self.reg * bi[iid])

        return bu, bi

    def predict(self, uid, iid):
        '''评分预测'''
        if iid not in self.items_ratings.index:
            raise Exception("无法预测用户<{uid}>对电影<{iid}>的评分，因为训练集中缺失<{iid}>的数据".format(uid=uid, iid=iid))

        predict_rating = self.global_mean + self.bu[uid] + self.bi[iid]
        return predict_rating

    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__':

    trainset, testset = data_split("datasets/ml-latest-small/ratings.csv", random=True)

    bcf = BaselineCFBySGD(20, 0.1, 0.1, ["userId", "movieId", "rating"])
    bcf.fit(trainset)

    pred_results = bcf.test(testset)

    rmse, mae = accuray(pred_results)

    print("rmse: ", rmse, "mae: ", mae)

方法二：交替最小二乘法优化

使用交替最小二乘法优化算法预测Baseline偏置值

step 1: 交替最小二乘法推导

最小二乘法和梯度下降法一样，可以用于求极值。

最小二乘法思想：对损失函数求偏导，然后再使偏导为0

同样，损失函数：
$$J(\theta )=\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i{)}^2+\lambda \ast (\sum _u{b_u}^2+\sum _i{b_i}^2)$$
对损失函数求偏导：
$$\frac{\partial }{\partial b_u}f(b_u,b_i)=-2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i)+2\lambda \ast b_u$$
令偏导为0，则可得：
$$\begin{gathered} \sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i)=\lambda \ast b_u \\ \sum _{u,i\in R}(r_{ui}-\mu -b_i)=\sum _{u,i\in R}{b}_u+\lambda \ast b_u \end{gathered}$$
为了简化公式，这里令${\sum }_{u,i\in R}{b}_u\approx |R(u)|\ast b_u$，即直接假设每一项的偏置都相等，可得：
$$b_u:=\frac{{\sum }_{u,i\in R}(r_{ui}-\mu -b_i)}{{\lambda }_1+|R(u)|}$$
其中$|R(u)|$表示用户 $u$ 的有过评分的数量

同理可得：
$$b_i:=\frac{{\sum }_{u,i\in R}(r_{ui}-\mu -b_u)}{{\lambda }_2+|R(i)|}$$
其中$|R(i)|$表示物品$i$收到的评分数量

$b_u$和$b_i$分别属于用户和物品的偏置，因此他们的正则参数可以分别设置两个独立的参数

step 2: 交替最小二乘法应用

通过最小二乘推导，我们最终分别得到了$b_u$和$b_i$的表达式，但他们的表达式中却又各自包含对方，因此这里我们将利用一种叫交替最小二乘的方法来计算他们的值：

• 计算其中一项，先固定其他未知参数，即看作其他未知参数为已知
• 如求$b_u$时，将$b_i$看作是已知；求$b_i$时，将$b_u$看作是已知；如此反复交替，不断更新二者的值，求得最终的结果。这就是交替最小二乘法（ALS）

step 3: 算法实现

import pandas as pd
import numpy as np


class BaselineCFByALS(object):

    def __init__(self, number_epochs, reg_bu, reg_bi, columns=["uid", "iid", "rating"]):
        # 梯度下降最高迭代次数
        self.number_epochs = number_epochs
        # bu的正则参数
        self.reg_bu = reg_bu
        # bi的正则参数
        self.reg_bi = reg_bi
        # 数据集中user-item-rating字段的名称
        self.columns = columns

    def fit(self, dataset):
        '''
        :param dataset: uid, iid, rating
        :return:
        '''
        self.dataset = 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.global_mean = self.dataset[self.columns[2]].mean()
        # 调用sgd方法训练模型参数
        self.bu, self.bi = self.als()

    def als(self):
        '''
        利用随机梯度下降，优化bu，bi的值
        :return: bu, bi
        '''
        # 初始化bu、bi的值，全部设为0
        bu = dict(zip(self.users_ratings.index, np.zeros(len(self.users_ratings))))
        bi = dict(zip(self.items_ratings.index, np.zeros(len(self.items_ratings))))

        for i in range(self.number_epochs):
            print("iter%d" % i)
            for iid, uids, ratings in self.items_ratings.itertuples(index=True):
                _sum = 0
                for uid, rating in zip(uids, ratings):
                    _sum += rating - self.global_mean - bu[uid]
                bi[iid] = _sum / (self.reg_bi + len(uids))

            for uid, iids, ratings in self.users_ratings.itertuples(index=True):
                _sum = 0
                for iid, rating in zip(iids, ratings):
                    _sum += rating - self.global_mean - bi[iid]
                bu[uid] = _sum / (self.reg_bu + len(iids))
        return bu, bi

    def predict(self, uid, iid):
        predict_rating = self.global_mean + self.bu[uid] + self.bi[iid]
        return predict_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))

    bcf = BaselineCFByALS(20, 25, 15, ["userId", "movieId", "rating"])
    bcf.fit(dataset)

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

Step 4: 准确性指标评估

import pandas as pd
import numpy as np

def data_split(data_path, x=0.8, random=False):
    '''
    切分数据集， 这里为了保证用户数量保持不变，将每个用户的评分数据按比例进行拆分
    :param data_path: 数据集路径
    :param x: 训练集的比例，如x=0.8，则0.2是测试集
    :param random: 是否随机切分，默认False
    :return: 用户-物品评分矩阵
    '''
    print("开始切分数据集...")
    # 设置要加载的数据字段的类型
    dtype = {"userId": np.int32, "movieId": np.int32, "rating": np.float32}
    # 加载数据，我们只用前三列数据，分别是用户ID，电影ID，已经用户对电影的对应评分
    ratings = pd.read_csv(data_path, dtype=dtype, usecols=range(3))

    testset_index = []
    # 为了保证每个用户在测试集和训练集都有数据，因此按userId聚合
    for uid in ratings.groupby("userId").any().index:
        user_rating_data = ratings.where(ratings["userId"]==uid).dropna()
        if random:
            # 因为不可变类型不能被 shuffle方法作用，所以需要强行转换为列表
            index = list(user_rating_data.index)
            np.random.shuffle(index)    # 打乱列表
            _index = round(len(user_rating_data) * x)
            testset_index += list(index[_index:])
        else:
            # 将每个用户的x比例的数据作为训练集，剩余的作为测试集
            index = round(len(user_rating_data) * x)
            testset_index += list(user_rating_data.index.values[index:])

    testset = ratings.loc[testset_index]
    trainset = ratings.drop(testset_index)
    print("完成数据集切分...")
    return trainset, testset

def accuray(predict_results, method="all"):
    '''
    准确性指标计算方法
    :param predict_results: 预测结果，类型为容器，每个元素是一个包含uid,iid,real_rating,pred_rating的序列
    :param method: 指标方法，类型为字符串，rmse或mae，否则返回两者rmse和mae
    :return:
    '''

    def rmse(predict_results):
        '''
        rmse评估指标
        :param predict_results:
        :return: rmse
        '''
        length = 0
        _rmse_sum = 0
        for uid, iid, real_rating, pred_rating in predict_results:
            length += 1
            _rmse_sum += (pred_rating - real_rating) ** 2
        return round(np.sqrt(_rmse_sum / length), 4)

    def mae(predict_results):
        '''
        mae评估指标
        :param predict_results:
        :return: mae
        '''
        length = 0
        _mae_sum = 0
        for uid, iid, real_rating, pred_rating in predict_results:
            length += 1
            _mae_sum += abs(pred_rating - real_rating)
        return round(_mae_sum / length, 4)

    def rmse_mae(predict_results):
        '''
        rmse和mae评估指标
        :param predict_results:
        :return: rmse, mae
        '''
        length = 0
        _rmse_sum = 0
        _mae_sum = 0
        for uid, iid, real_rating, pred_rating in predict_results:
            length += 1
            _rmse_sum += (pred_rating - real_rating) ** 2
            _mae_sum += abs(pred_rating - real_rating)
        return round(np.sqrt(_rmse_sum / length), 4), round(_mae_sum / length, 4)

    if method.lower() == "rmse":
        rmse(predict_results)
    elif method.lower() == "mae":
        mae(predict_results)
    else:
        return rmse_mae(predict_results)

class BaselineCFByALS(object):

    def __init__(self, number_epochs, reg_bu, reg_bi, columns=["uid", "iid", "rating"]):
        # 梯度下降最高迭代次数
        self.number_epochs = number_epochs
        # bu的正则参数
        self.reg_bu = reg_bu
        # bi的正则参数
        self.reg_bi = reg_bi
        # 数据集中user-item-rating字段的名称
        self.columns = columns

    def fit(self, dataset):
        '''
        :param dataset: uid, iid, rating
        :return:
        '''
        self.dataset = 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.global_mean = self.dataset[self.columns[2]].mean()
        # 调用sgd方法训练模型参数
        self.bu, self.bi = self.als()

    def als(self):
        '''
        利用随机梯度下降，优化bu，bi的值
        :return: bu, bi
        '''
        # 初始化bu、bi的值，全部设为0
        bu = dict(zip(self.users_ratings.index, np.zeros(len(self.users_ratings))))
        bi = dict(zip(self.items_ratings.index, np.zeros(len(self.items_ratings))))

        for i in range(self.number_epochs):
            print("iter%d" % i)
            for iid, uids, ratings in self.items_ratings.itertuples(index=True):
                _sum = 0
                for uid, rating in zip(uids, ratings):
                    _sum += rating - self.global_mean - bu[uid]
                bi[iid] = _sum / (self.reg_bi + len(uids))

            for uid, iids, ratings in self.users_ratings.itertuples(index=True):
                _sum = 0
                for iid, rating in zip(iids, ratings):
                    _sum += rating - self.global_mean - bi[iid]
                bu[uid] = _sum / (self.reg_bu + len(iids))
        return bu, bi

    def predict(self, uid, iid):
        '''评分预测'''
        if iid not in self.items_ratings.index:
            raise Exception("无法预测用户<{uid}>对电影<{iid}>的评分，因为训练集中缺失<{iid}>的数据".format(uid=uid, iid=iid))

        predict_rating = self.global_mean + self.bu[uid] + self.bi[iid]
        return predict_rating

    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__':
    trainset, testset = data_split("datasets/ml-latest-small/ratings.csv", random=True)

    bcf = BaselineCFByALS(20, 25, 15, ["userId", "movieId", "rating"])
    bcf.fit(trainset)

    pred_results = bcf.test(testset)

    rmse, mae = accuray(pred_results)

    print("rmse: ", rmse, "mae: ", mae)

函数求导：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z3obT7Xj-1678011026571)(./img/常见函数求导.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cPry5Srt-1678011026576)(./img/导数的四则运算.png)]

基于矩阵分解的CF算法

矩阵分解发展史

Traditional SVD

通常SVD矩阵分解指的是SVD（奇异值）分解技术，在这我们姑且将其命名为Traditional SVD（传统并经典着）其公式如下：

$$M_{m\times n}=U_{m\times k}{\Sigma }_{k\times k}{V}_{k\times n}^T$$

Traditional SVD分解的形式为3个矩阵相乘，中间矩阵为奇异值矩阵。如果想运用SVD分解的话，有一个前提是要求矩阵是稠密的，即矩阵里的元素要非空，否则就不能运用SVD分解。

很显然我们的数据其实绝大多数情况下都是稀疏的，因此如果要使用Traditional SVD，一般的做法是先用均值或者其他统计学方法来填充矩阵，然后再运用Traditional SVD分解降维，但这样做明显对数据的原始性造成一定影响。

FunkSVD（LFM）

刚才提到的Traditional SVD首先需要填充矩阵，然后再进行分解降维，同时存在计算复杂度高的问题，因为要分解成3个矩阵，所以后来提出了Funk SVD的方法，它不再将矩阵分解为3个矩阵，而是分解为2个用户-隐含特征，项目-隐含特征的矩阵，Funk SVD也被称为最原始的LFM模型

$$\sum _{i,j}(m_{i.j}-q_j^T{p}_i{)}^2$$

借鉴线性回归的思想，通过最小化观察数据的平方来寻求最优的用户和项目的隐含向量表示。同时为了避免过度拟合（Overfitting）观测数据，又提出了带有L2正则项的FunkSVD，上公式：
$$mi{n}_{q\ast ,p\ast }\sum _{(u,i)\in \mathrm{K}}(r_{ui}-q_i^T{p}_u{)}^2+\lambda ({\Vert q_i\Vert }^2+{\Vert p_u\Vert }^2)$$

以上两种最优化函数都可以通过梯度下降或者随机梯度下降法来寻求最优解。

BiasSVD:

在FunkSVD提出来之后，出现了很多变形版本，其中一个相对成功的方法是BiasSVD，顾名思义，即带有偏置项的SVD分解：
$$\underset{p_i,q_j}{\arg \min }\sum _{i,j}{\left(m_{ij}-\mu -b_i-b_j-q_j^T{p}_i\right)}^2+\lambda ({\Vert p_i\Vert }_2^2+{\Vert q_j\Vert }_2^2+{\Vert b_i\Vert }_2^2+{\Vert b_j\Vert }_2^2)$$

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sGG11HuN-1678011026578)(./img/矩阵分解4.jpg)]

它基于的假设和Baseline基准预测是一样的，但这里将Baseline的偏置引入到了矩阵分解中

SVD++

人们后来又提出了改进的BiasSVD，被称为SVD++，该算法是在BiasSVD的基础上添加了用户的隐式反馈信息：
arg ⁡ min ⁡ ⏟ p i , q i ∑ i , j ( m i j − μ − b i − b j − q j T p i − q j T ∣ N ( i ) ∣ − 1 2 ∑ s ∈ N ( i ) y s ) 2 + λ ( ∥ p i ∥ 2 2 + ∥ q j ∥ 2 2 + ∥ b i ∥ 2 2 + ∥ b j ∥ 2 2 + ∑ s ∈ N ( i ) ∥ y s ∥ 2 2 ) \underbrace {\arg \min }_{{p_i},{q_i}}{\sum\limits_{i,j} {\left( {{m_{ij}} - \mu - {b_i} - {b_j} - q_j^T{p_i} - q_j^T{{\left| {N(i)} \right|}^{ - \frac{1}{2}}}\sum\limits_{s \in N(i)} {{y_s}} } \right)} ^2}\\ + \lambda (\left\| {{p_i}} \right\|_2^2 + \left\| {{q_j}} \right\|_2^2 + \left\| {{b_i}} \right\|_2^2 + \left\| {{b_j}} \right\|_2^2 + \sum\limits_{s \in N(i)} {\left\| {{y_s}} \right\|_2^2} ) pi​,qi​ argmin​​i,j∑​ ​mij​−μ−bi​−bj​−qjT​pi​−qjT​∣N(i)∣−21​s∈N(i)∑​ys​ ​2+λ(∥pi​∥22​+∥qj​∥22​+∥bi​∥22​+∥bj​∥22​+s∈N(i)∑​∥ys​∥22​)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iLDmyPG6-1678011026580)(./img/矩阵分解5.jpg)]

显示反馈指的用户的评分这样的行为，隐式反馈指用户的浏览记录、购买记录、收听记录等。

SVD++是基于这样的假设：在BiasSVD基础上，认为用户对于项目的历史浏览记录、购买记录、收听记录等可以从侧面反映用户的偏好。

基于矩阵分解的CF算法实现（一）：LFM

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

LFM原理解析

LFM(latent factor model)隐语义模型核心思想是通过隐含特征联系用户和物品，如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kbgzcOz9-1678011026582)(./img/LFM矩阵分解图解.png)]

• P矩阵是User-LF矩阵，即用户和隐含特征矩阵。LF有三个，表示共总有三个隐含特征。
• Q矩阵是LF-Item矩阵，即隐含特征和物品的矩阵
• R矩阵是User-Item矩阵，有P*Q得来
• 能处理稀疏评分矩阵

利用矩阵分解技术，将原始User-Item的评分矩阵（稠密/稀疏）分解为P和Q矩阵，然后利用$P\ast Q$还原出User-Item评分矩阵$R$。整个过程相当于降维处理，其中：

• 矩阵值$P_{11}$表示用户1对隐含特征1的权重值

• 矩阵值$Q_{11}$表示隐含特征1在物品1上的权重值

• 矩阵值$R_{11}$就表示预测的用户1对物品1的评分，且$R_{11}=P_{1,k}\cdot Q_{k,1}$

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5CFLLnYt-1678011026583)(./img/LFM矩阵分解图解2.png)]

利用LFM预测用户对物品的评分，$k$表示隐含特征数量：
$$\begin{array}{rl}{\hat{r}}_{ui}& =p_{uk}\cdot q_{ik}\\ & ={\sum _{k=1}}^k{p}_{uk}{q}_{ik}\end{array}$$
因此最终，我们的目标也就是要求出P矩阵和Q矩阵及其当中的每一个值，然后再对用户-物品的评分进行预测。

损失函数

同样对于评分预测我们利用平方差来构建损失函数：
$$\begin{array}{rl}Cost& =\sum _{u,i\in R}(r_{ui}-{\hat{r}}_{ui}{)}^2\\ & =\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2\end{array}$$
加入L2正则化：
$$Cost=\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2+\lambda (\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2)$$
对损失函数求偏导：
$$\begin{array}{rl}\frac{\partial }{\partial p_{uk}}Cost& =\frac{\partial }{\partial p_{uk}}[\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2+\lambda (\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2)]\\ & =2\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-q_{ik})+2\lambda p_{uk}\\ & \\ \frac{\partial }{\partial q_{ik}}Cost& =\frac{\partial }{\partial q_{ik}}[\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2+\lambda (\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2)]\\ & =2\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-p_{uk})+2\lambda q_{ik}\end{array}$$

随机梯度下降法优化

梯度下降更新参数$p_{uk}$：
$$\begin{array}{rl}{p}_{uk}& :=p_{uk}-\alpha \frac{\partial }{\partial p_{uk}}Cost\\ & :=p_{uk}-\alpha [2\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-q_{ik})+2\lambda p_{uk}]\\ & :=p_{uk}+\alpha [\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})q_{ik}-\lambda p_{uk}]\end{array}$$
同理：
$$\begin{array}{rl}{q}_{ik}& :=q_{ik}+\alpha [\sum _{u,i\in R}(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})p_{uk}-\lambda q_{ik}]\end{array}$$
随机梯度下降： 向量乘法 每一个分量相乘 求和
$$\begin{array}{rl}& p_{uk}:=p_{uk}+\alpha [(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})q_{ik}-{\lambda }_1{p}_{uk}]\\ & q_{ik}:=q_{ik}+\alpha [(r_{ui}-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})p_{uk}-{\lambda }_2{q}_{ik}]\end{array}$$
由于P矩阵和Q矩阵是两个不同的矩阵，通常分别采取不同的正则参数，如${\lambda }_1$和${\lambda }_2$

算法实现

'''
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)))

基于矩阵分解的CF算法实现（二）：BiasSvd

BiasSvd其实就是前面提到的Funk SVD矩阵分解基础上加上了偏置项。

BiasSvd

利用BiasSvd预测用户对物品的评分，$k$表示隐含特征数量：
$$\begin{array}{rl}{\hat{r}}_{ui}& =\mu +b_u+b_i+p_{uk}\cdot q_{ki}\\ & =\mu +b_u+b_i+{\sum _{k=1}}^k{p}_{uk}{q}_{ik}\end{array}$$

损失函数

同样对于评分预测我们利用平方差来构建损失函数：
$$\begin{array}{rl}Cost& =\sum _{u,i\in R}(r_{ui}-{\hat{r}}_{ui}{)}^2\\ & =\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2\end{array}$$
加入L2正则化：
$$\begin{gathered} Cost=\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2 \\ +\lambda (\sum _U{b_u}^2+\sum _I{b_i}^2+\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2) \end{gathered}$$
对损失函数求偏导：
$$\begin{array}{rl}\frac{\partial }{\partial p_{uk}}Cost& =\frac{\partial }{\partial p_{uk}}[\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2+\lambda (\sum _U{b_u}^2+\sum _I{b_i}^2+\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2)]\\ & =2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-q_{ik})+2\lambda p_{uk}\\ & \\ \frac{\partial }{\partial q_{ik}}Cost& =\frac{\partial }{\partial q_{ik}}[\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2+\lambda (\sum _U{b_u}^2+\sum _I{b_i}^2+\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2)]\\ & =2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-p_{uk})+2\lambda q_{ik}\end{array}$$

$$\begin{array}{rl}\frac{\partial }{\partial b_u}Cost& =\frac{\partial }{\partial b_u}[\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2+\lambda (\sum _U{b_u}^2+\sum _I{b_i}^2+\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2)]\\ & =2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-1)+2\lambda b_u\\ & \\ \frac{\partial }{\partial b_i}Cost& =\frac{\partial }{\partial b_i}[\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik}{)}^2+\lambda (\sum _U{b_u}^2+\sum _I{b_i}^2+\sum _U{p_{uk}}^2+\sum _I{q_{ik}}^2)]\\ & =2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-1)+2\lambda b_i\end{array}$$

随机梯度下降法优化

梯度下降更新参数$p_{uk}$：
$$\begin{array}{rl}{p}_{uk}& :=p_{uk}-\alpha \frac{\partial }{\partial p_{uk}}Cost\\ & :=p_{uk}-\alpha [2\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})(-q_{ik})+2\lambda p_{uk}]\\ & :=p_{uk}+\alpha [\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})q_{ik}-\lambda p_{uk}]\end{array}$$
同理：
$$\begin{array}{rl}{q}_{ik}& :=q_{ik}+\alpha [\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})p_{uk}-\lambda q_{ik}]\end{array}$$

$$b_u:=b_u+\alpha [\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})-\lambda b_u]$$

$$b_i:=b_i+\alpha [\sum _{u,i\in R}(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})-\lambda b_i]$$

随机梯度下降：
$$\begin{array}{rl}& p_{uk}:=p_{uk}+\alpha [(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})q_{ik}-{\lambda }_1{p}_{uk}]\\ & q_{ik}:=q_{ik}+\alpha [(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})p_{uk}-{\lambda }_2{q}_{ik}]\end{array}$$

$$b_u:=b_u+\alpha [(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})-{\lambda }_3{b}_u]$$

$$b_i:=b_i+\alpha [(r_{ui}-\mu -b_u-b_i-{\sum _{k=1}}^k{p}_{uk}{q}_{ik})-{\lambda }_4{b}_i]$$

由于P矩阵和Q矩阵是两个不同的矩阵，通常分别采取不同的正则参数，如${\lambda }_1$和${\lambda }_2$

算法实现

'''
BiasSvd Model
'''
import math
import random
import pandas as pd
import numpy as np

class BiasSvd(object):

    def __init__(self, alpha, reg_p, reg_q, reg_bu, reg_bi, number_LatentFactors=10, number_epochs=10, columns=["uid", "iid", "rating"]):
        self.alpha = alpha # 学习率
        self.reg_p = reg_p
        self.reg_q = reg_q
        self.reg_bu = reg_bu
        self.reg_bi = reg_bi
        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.bu, self.bi = 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()

        # 初始化bu、bi的值，全部设为0
        bu = dict(zip(self.users_ratings.index, np.zeros(len(self.users_ratings))))
        bi = dict(zip(self.items_ratings.index, np.zeros(len(self.items_ratings))))

        for i in range(self.number_epochs):
            print("iter%d"%i)
            error_list = []
            for uid, iid, r_ui in self.dataset.itertuples(index=False):
                v_pu = P[uid]
                v_qi = Q[iid]
                err = np.float32(r_ui - self.globalMean - bu[uid] - bi[iid] - 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
                
                bu[uid] += self.alpha * (err - self.reg_bu * bu[uid])
                bi[iid] += self.alpha * (err - self.reg_bi * bi[iid])

                error_list.append(err ** 2)
            print(np.sqrt(np.mean(error_list)))

        return P, Q, bu, bi

    def predict(self, 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 self.globalMean + self.bu[uid] + self.bi[iid] + np.dot(p_u, q_i)


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))

    bsvd = BiasSvd(0.02, 0.01, 0.01, 0.01, 0.01, 10, 20)
    bsvd.fit(dataset)

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