【推荐系统案例】基于协同过滤的电影推荐

客官°小女子只卖身不卖艺 2022-08-28 02:49 255阅读 0赞

### 案例--基于协同过滤的电影推荐 ###

*  1. 数据集下载
 *  2. 数据集加载
 *  3. 相似度计算
 *  4. User-Based CF 预测评分算法实现
 *  5. Item-Based CF 预测评分算法实现

前面我们已经基本掌握了**协同过滤推荐算法**，以及其中两种最基本的实现方案：**User-Based CF**和**Item-Based CF**，下面我们将利用真实的数据来进行实战演练。

案例需求

演示效果

分析案例

# 1. 数据集下载 #

[MovieLens Latest Datasets Small][]

建议下载[ml-latest-small.zip][]，数据量小，便于我们单机使用和运行

**目标**：根据`ml-latest-small/ratings.csv`（用户-电影评分数据），分别实现User-Based CF和Item-Based CF，并进行电影评分的预测，然后为用户实现电影推荐

# 2. 数据集加载 #

*  加载`ratings.csv`，并转换为用户-电影评分矩阵
    
        import os
        
        import pandas as pd
        import numpy as np
        
        DATA_PATH = "./datasets/ml-latest-small/ratings.csv"
        CACHE_DIR = "./datasets/cache/"
        
        def load_data(data_path):
            '''
            加载数据
            :param data_path: 数据集路径
            :param cache_path: 数据集缓存路径
            :return: 用户-物品评分矩阵
            '''
            # 数据集缓存地址
            cache_path = os.path.join(CACHE_DIR, "ratings_matrix.cache")
        
            print("开始加载数据集...")
            if os.path.exists(cache_path):    # 判断是否存在缓存文件
                print("加载缓存中...")
                ratings_matrix = pd.read_pickle(cache_path)
                print("从缓存加载数据集完毕")
            else:
                print("加载新数据中...")
                # 设置要加载的数据字段的类型
                dtype = {
              "userId": np.int32, "movieId": np.int32, "rating": np.float32}
                # 加载数据，我们只用前三列数据，分别是用户ID，电影ID，已经用户对电影的对应评分
                ratings = pd.read_csv(data_path, dtype=dtype, usecols=range(3))
                # 透视表，将电影ID转换为列名称，转换成为一个User-Movie的评分矩阵
                ratings_matrix = ratings.pivot_table(index=["userId"], columns=["movieId"], values="rating")
                # 存入缓存文件
                ratings_matrix.to_pickle(cache_path)
                print("数据集加载完毕")
                
            return  ratings_matrix
        
        if __name__ == '__main__':
            ratings_matrix = load_data(DATA_PATH)
            print(ratings_matrix)

# 3. 相似度计算 #

*  计算用户或物品两两相似度：
    
        # ......
        
        def compute_pearson_similarity(ratings_matrix, based="user"):
            '''
            计算皮尔逊相关系数
            :param ratings_matrix: 用户-物品评分矩阵
            :param based: "user" or "item"
            :return: 相似度矩阵
            '''
            user_similarity_cache_path = os.path.join(CACHE_DIR, "user_similarity.cache")
            item_similarity_cache_path = os.path.join(CACHE_DIR, "item_similarity.cache")
            # 基于皮尔逊相关系数计算相似度
            # 用户相似度
            if based == "user":
                if os.path.exists(user_similarity_cache_path):
                    print("正从缓存加载用户相似度矩阵")
                    similarity = pd.read_pickle(user_similarity_cache_path)
                else:
                    print("开始计算用户相似度矩阵")
                    similarity = ratings_matrix.T.corr()
                    similarity.to_pickle(user_similarity_cache_path)
        
            elif based == "item":
                if os.path.exists(item_similarity_cache_path):
                    print("正从缓存加载物品相似度矩阵")
                    similarity = pd.read_pickle(item_similarity_cache_path)
                else:
                    print("开始计算物品相似度矩阵")
                    similarity = ratings_matrix.corr()
                    similarity.to_pickle(item_similarity_cache_path)
            else:
                raise Exception("Unhandled 'based' Value: %s"%based)
            print("相似度矩阵计算/加载完毕")
            return similarity
        
        if __name__ == '__main__':
        
            ratings_matrix = load_data(DATA_PATH)
        
            user_similar = compute_pearson_similarity(ratings_matrix, based="user")
            print(user_similar)
            item_similar = compute_pearson_similarity(ratings_matrix, based="item")
            print(item_similar)

**注意**

以上实现，仅用于实验阶段，因为工业上、或生产环境中，数据量是远超过我们本例中使用的数据量的，而pandas是无法支撑起大批量数据的运算的，因此工业上通常会使用spark、mapReduce等分布式计算框架来实现，我们后面的课程中也是建立在此基础上进行实践的。

但是正如前面所说，推荐算法的思想和理念都是统一的，不论使用什么平台工具、有多大的数据体量，其背后的实现原理都是不变的。

所以在本节，大家要深刻去学习的是推荐算法的业务流程，以及在具体的业务场景中，如本例的电影推荐，如何实现出推荐算法，并产生推荐结果。

# 4. User-Based CF 预测评分算法实现 #

**评分预测公式：**  
 p r e d ( u , i ) = r ^ u i = ∑ v ∈ U s i m ( u , v ) ∗ r v i ∑ v ∈ U ∣ s i m ( u , v ) ∣ pred(u,i)=\\hat\{r\}\_\{ui\}=\\cfrac\{\\sum\_\{v\\in U\}sim(u,v)\*r\_\{vi\}\}\{\\sum\_\{v\\in U\}|sim(u,v)|\} pred(u,i)=r^ui=∑v∈U∣sim(u,v)∣∑v∈Usim(u,v)∗rvi

**算法实现**

*  实现评分预测方法：`predict`
    
        # ......
        
        def predict(uid, iid, ratings_matrix, user_similar):
            '''
            预测给定用户对给定物品的评分值
            :param uid: 用户ID
            :param iid: 物品ID
            :param ratings_matrix: 用户-物品评分矩阵
            :param user_similar: 用户两两相似度矩阵
            :return: 预测的评分值
            '''
            print("开始预测用户<%d>对电影<%d>的评分..."%(uid, iid))
            # 1. 找出uid用户的相似用户
            similar_users = user_similar[uid].drop([uid]).dropna()
            # 相似用户筛选规则：正相关的用户
            similar_users = similar_users.where(similar_users>0).dropna()
            
            if similar_users.empty is True:
                raise Exception("用户<%d>没有相似的用户" % uid)
        
            # 2. 从uid用户的近邻相似用户中筛选出对iid物品有评分记录的近邻用户
            ids = set(ratings_matrix[iid].dropna().index)&set(similar_users.index)
            finally_similar_users = similar_users.ix[list(ids)]
        
            # 3. 结合uid用户与其近邻用户的相似度预测uid用户对iid物品的评分
            sum_up = 0    # 评分预测公式的分子部分的值
            sum_down = 0    # 评分预测公式的分母部分的值
            for sim_uid, similarity in finally_similar_users.iteritems():
                # 近邻用户的评分数据
                sim_user_rated_movies = ratings_matrix.ix[sim_uid].dropna()
                # 近邻用户对iid物品的评分
                sim_user_rating_for_item = sim_user_rated_movies[iid]
                # 计算分子的值
                sum_up += similarity * sim_user_rating_for_item
                # 计算分母的值
                sum_down += similarity
        
            # 计算预测的评分值并返回
            predict_rating = sum_up/sum_down
            print("预测出用户<%d>对电影<%d>的评分：%0.2f" % (uid, iid, predict_rating))
            return round(predict_rating, 2)
        
        if __name__ == '__main__':
            ratings_matrix = load_data(DATA_PATH)
        
            user_similar = compute_pearson_similarity(ratings_matrix, based="user")
            # 预测用户1对物品1的评分
            predict(1, 1, ratings_matrix, user_similar)
            # 预测用户1对物品2的评分
            predict(1, 2, ratings_matrix, user_similar)
 *  实现预测全部评分方法：`predict_all`
    
        # ......
        def predict_all(uid, ratings_matrix, user_similar):
            '''
            预测全部评分
            :param uid: 用户id
            :param ratings_matrix: 用户-物品打分矩阵
            :param user_similar: 用户两两间的相似度
            :return: 生成器，逐个返回预测评分
            '''
            # 准备要预测的物品的id列表
            item_ids = ratings_matrix.columns
            # 逐个预测
            for iid in item_ids:
                try:
                    rating = predict(uid, iid, ratings_matrix, user_similar)
                except Exception as e:
                    print(e)
                else:
                    yield uid, iid, rating
        
        if __name__ == '__main__':
            ratings_matrix = load_data(DATA_PATH)
        
            user_similar = compute_pearson_similarity(ratings_matrix, based="user")
        
            for i in predict_all(1, ratings_matrix, user_similar):
                pass
 *  添加过滤规则
    
        def _predict_all(uid, item_ids, ratings_matrix, user_similar):
            '''
            预测全部评分
            :param uid: 用户id
            :param item_ids: 要预测的物品id列表
            :param ratings_matrix: 用户-物品打分矩阵
            :param user_similar: 用户两两间的相似度
            :return: 生成器，逐个返回预测评分
            '''
            # 逐个预测
            for iid in item_ids:
                try:
                    rating = predict(uid, iid, ratings_matrix, user_similar)
                except Exception as e:
                    print(e)
                else:
                    yield uid, iid, rating
        
        def predict_all(uid, ratings_matrix, user_similar, filter_rule=None):
            '''
            预测全部评分，并可根据条件进行前置过滤
            :param uid: 用户ID
            :param ratings_matrix: 用户-物品打分矩阵
            :param user_similar: 用户两两间的相似度
            :param filter_rule: 过滤规则，只能是四选一，否则将抛异常："unhot","rated",["unhot","rated"],None
            :return: 生成器，逐个返回预测评分
            '''
        
            if not filter_rule:
                item_ids = ratings_matrix.columns
            elif isinstance(filter_rule, str) and filter_rule == "unhot":
                '''过滤非热门电影'''
                # 统计每部电影的评分数
                count = ratings_matrix.count()
                # 过滤出评分数高于10的电影，作为热门电影
                item_ids = count.where(count>10).dropna().index
            elif isinstance(filter_rule, str) and filter_rule == "rated":
                '''过滤用户评分过的电影'''
                # 获取用户对所有电影的评分记录
                user_ratings = ratings_matrix.ix[uid]
                # 评分范围是1-5，小于6的都是评分过的，除此以外的都是没有评分的
                _ = user_ratings<6
                item_ids = _.where(_==False).dropna().index
            elif isinstance(filter_rule, list) and set(filter_rule) == set(["unhot", "rated"]):
                '''过滤非热门和用户已经评分过的电影'''
                count = ratings_matrix.count()
                ids1 = count.where(count > 10).dropna().index
        
                user_ratings = ratings_matrix.ix[uid]
                _ = user_ratings < 6
                ids2 = _.where(_ == False).dropna().index
                # 取二者交集
                item_ids = set(ids1)&set(ids2)
            else:
                raise Exception("无效的过滤参数")
        
            yield from _predict_all(uid, item_ids, ratings_matrix, user_similar)
        
        if __name__ == '__main__':
            ratings_matrix = load_data(DATA_PATH)
        
            user_similar = compute_pearson_similarity(ratings_matrix, based="user")
        
            for result in predict_all(1, ratings_matrix, user_similar, filter_rule=["unhot", "rated"]):
                print(result)
 *  根据预测评分为指定用户进行TOP-N推荐：
    
        # ......
        
        def top_k_rs_result(k):
            ratings_matrix = load_data(DATA_PATH)
            user_similar = compute_pearson_similarity(ratings_matrix, based="user")
            results = predict_all(1, ratings_matrix, user_similar, filter_rule=["unhot", "rated"])
            return sorted(results, key=lambda x: x[2], reverse=True)[:k]
        
        if __name__ == '__main__':
            from pprint import pprint
            result = top_k_rs_result(20)
            pprint(result)

# 5. Item-Based CF 预测评分算法实现 #

**评分预测公式：**  
 p r e d ( u , i ) = r ^ u i = ∑ j ∈ I r a t e d s i m ( i , j ) ∗ r u j ∑ j ∈ I r a t e d s i m ( i , j ) pred(u,i)=\\hat\{r\}\_\{ui\}=\\cfrac\{\\sum\_\{j\\in I\_\{rated\}\}sim(i,j)\*r\_\{uj\}\}\{\\sum\_\{j\\in I\_\{rated\}\}sim(i,j)\} pred(u,i)=r^ui=∑j∈Iratedsim(i,j)∑j∈Iratedsim(i,j)∗ruj

**算法实现**

*  实现评分预测方法：`predict`
    
     *  方法说明：
        
        利用原始评分矩阵、以及物品间两两相似度，预测指定用户对指定物品的评分。
        
        如果无法预测，则抛出异常
    
        # ......
        
        def predict(uid, iid, ratings_matrix, item_similar):
            '''
            预测给定用户对给定物品的评分值
            :param uid: 用户ID
            :param iid: 物品ID
            :param ratings_matrix: 用户-物品评分矩阵
            :param item_similar: 物品两两相似度矩阵
            :return: 预测的评分值
            '''
            print("开始预测用户<%d>对电影<%d>的评分..."%(uid, iid))
            # 1. 找出iid物品的相似物品
            similar_items = item_similar[iid].drop([iid]).dropna()
            # 相似物品筛选规则：正相关的物品
            similar_items = similar_items.where(similar_items>0).dropna()
            if similar_items.empty is True:
                raise Exception("物品<%d>没有相似的物品" %id)
        
            # 2. 从iid物品的近邻相似物品中筛选出uid用户评分过的物品
            ids = set(ratings_matrix.ix[uid].dropna().index)&set(similar_items.index)
            finally_similar_items = similar_items.ix[list(ids)]
        
            # 3. 结合iid物品与其相似物品的相似度和uid用户对其相似物品的评分，预测uid对iid的评分
            sum_up = 0    # 评分预测公式的分子部分的值
            sum_down = 0    # 评分预测公式的分母部分的值
            for sim_iid, similarity in finally_similar_items.iteritems():
                # 近邻物品的评分数据
                sim_item_rated_movies = ratings_matrix[sim_iid].dropna()
                # uid用户对相似物品物品的评分
                sim_item_rating_from_user = sim_item_rated_movies[uid]
                # 计算分子的值
                sum_up += similarity * sim_item_rating_from_user
                # 计算分母的值
                sum_down += similarity
        
            # 计算预测的评分值并返回
            predict_rating = sum_up/sum_down
            print("预测出用户<%d>对电影<%d>的评分：%0.2f" % (uid, iid, predict_rating))
            return round(predict_rating, 2)
        
        if __name__ == '__main__':
            ratings_matrix = load_data(DATA_PATH)
        
            item_similar = compute_pearson_similarity(ratings_matrix, based="item")
            # 预测用户1对物品1的评分
            predict(1, 1, ratings_matrix, item_similar)
            # 预测用户1对物品2的评分
            predict(1, 2, ratings_matrix, item_similar)
 *  实现预测全部评分方法：`predict_all`
    
        # ......
        
        def predict_all(uid, ratings_matrix, item_similar):
            '''
            预测全部评分
            :param uid: 用户id
            :param ratings_matrix: 用户-物品打分矩阵
            :param item_similar: 物品两两间的相似度
            :return: 生成器，逐个返回预测评分
            '''
            # 准备要预测的物品的id列表
            item_ids = ratings_matrix.columns
            # 逐个预测
            for iid in item_ids:
                try:
                    rating = predict(uid, iid, ratings_matrix, item_similar)
                except Exception as e:
                    print(e)
                else:
                    yield uid, iid, rating
        
        if __name__ == '__main__':
            ratings_matrix = load_data(DATA_PATH)
        
            item_similar = compute_pearson_similarity(ratings_matrix, based="item")
            for i in predict_all(1, ratings_matrix, item_similar):
                pass
 *  添加过滤规则
    
        def _predict_all(uid, item_ids,ratings_matrix, item_similar):
            '''
            预测全部评分
            :param uid: 用户id
            :param item_ids: 要预测物品id列表
            :param ratings_matrix: 用户-物品打分矩阵
            :param item_similar: 物品两两间的相似度
            :return: 生成器，逐个返回预测评分
            '''
            # 逐个预测
            for iid in item_ids:
                try:
                    rating = predict(uid, iid, ratings_matrix, item_similar)
                except Exception as e:
                    print(e)
                else:
                    yield uid, iid, rating
        
        def predict_all(uid, ratings_matrix, item_similar, filter_rule=None):
            '''
            预测全部评分，并可根据条件进行前置过滤
            :param uid: 用户ID
            :param ratings_matrix: 用户-物品打分矩阵
            :param item_similar: 物品两两间的相似度
            :param filter_rule: 过滤规则，只能是四选一，否则将抛异常："unhot","rated",["unhot","rated"],None
            :return: 生成器，逐个返回预测评分
            '''
        
            if not filter_rule:
                item_ids = ratings_matrix.columns
            elif isinstance(filter_rule, str) and filter_rule == "unhot":
                '''过滤非热门电影'''
                # 统计每部电影的评分数
                count = ratings_matrix.count()
                # 过滤出评分数高于10的电影，作为热门电影
                item_ids = count.where(count>10).dropna().index
            elif isinstance(filter_rule, str) and filter_rule == "rated":
                '''过滤用户评分过的电影'''
                # 获取用户对所有电影的评分记录
                user_ratings = ratings_matrix.ix[uid]
                # 评分范围是1-5，小于6的都是评分过的，除此以外的都是没有评分的
                _ = user_ratings<6
                item_ids = _.where(_==False).dropna().index
            elif isinstance(filter_rule, list) and set(filter_rule) == set(["unhot", "rated"]):
                '''过滤非热门和用户已经评分过的电影'''
                count = ratings_matrix.count()
                ids1 = count.where(count > 10).dropna().index
        
                user_ratings = ratings_matrix.ix[uid]
                _ = user_ratings < 6
                ids2 = _.where(_ == False).dropna().index
                # 取二者交集
                item_ids = set(ids1)&set(ids2)
            else:
                raise Exception("无效的过滤参数")
        
            yield from _predict_all(uid, item_ids, ratings_matrix, item_similar)
        
        if __name__ == '__main__':
            ratings_matrix = load_data(DATA_PATH)
        
            item_similar = compute_pearson_similarity(ratings_matrix, based="item")
        
            for result in predict_all(1, ratings_matrix, item_similar, filter_rule=["unhot", "rated"]):
                print(result)
 *  为指定用户推荐TOP-N结果
    
        # ......
        
        def top_k_rs_result(k):
            ratings_matrix = load_data(DATA_PATH)
        
            item_similar = compute_pearson_similarity(ratings_matrix, based="item")
            results = predict_all(1, ratings_matrix, item_similar, filter_rule=["unhot", "rated"])
            return sorted(results, key=lambda x: x[2], reverse=True)[:k]
        
        if __name__ == '__main__':
            from pprint import pprint
            result = top_k_rs_result(20)
            pprint(result)

--------------------

**加油!**

**感谢!**

**努力!**

[MovieLens Latest Datasets Small]: https://grouplens.org/datasets/movielens/latest/
[ml-latest-small.zip]: http://files.grouplens.org/datasets/movielens/ml-latest-small.zip