Python协同过滤电影推荐系统：从公式到可答辩的完整实现

简介：本资源是一套完整的基于Python的协同过滤推荐算法电影推荐系统，专为计算机相关专业本科生毕业设计、课程设计及项目实战学习者打造，有效解决推荐系统原理理解与工程落地脱节问题。压缩包共1197个文件，含22个核心Python源码文件（实现用户/物品相似度计算、评分预测与推荐生成）、4个CSV数据集（含电影信息与用户行为记录）、1个SQLite3数据库及配套前端资源（HTML/CSS/JS共50余文件，支持网页交互式推荐展示），另有大量JPG/PNG图片素材用于界面渲染，整体大小76.75MB。目前已有146人学习下载，资源经严格调试，下载解压后可直接运行，附带完整目录结构与模块化代码组织，便于理解推荐流程各环节（数据预处理→相似度计算→Top-N推荐→结果可视化），特别适合毕设快速启动与算法实践深化。

1. 这不是“调个库跑个 demo”的电影推荐——它是一套能过答辩、可复现、带数据闭环的协同过滤落地方案

你手头有一份标着“Python 基于协同过滤推荐算法的电影推荐系统源码+全部数据（毕业设计）”的压缩包，点开发现：data/下有ratings.csv和movies.csv，model/里是user_cf.py和item_cf.py，app.py能启动一个简易 Web 界面——但运行报错ModuleNotFoundError: No module named 'scikit-surprise'，改用pip install surprise又提示Building wheel for scikit-surprise failed；或者更糟：训练完模型，输入用户 ID 却返回KeyError: 123，而你翻遍ratings.csv才发现用户 ID 是从 1 开始连续编号，但数据里实际存在大量跳号和缺失。这不是代码写错了，而是协同过滤在真实数据场景下的典型断层：理论公式（如余弦相似度、皮尔逊相关系数）和工程落地（稀疏矩阵构建、冷启动处理、ID 映射一致性、评估指标对齐）之间，隔着三道必须亲手填平的坑。本篇不讲“推荐系统是什么”，只聚焦毕业设计最卡脖子的环节：如何用 Python 把协同过滤从公式推导，变成可调试、可展示、可解释、能应对答辩老师“这个 RMSE 是怎么算出来的？”提问的完整链路。适合正在赶毕设 deadline、已下载源码但跑不通、或想自己重写核心模块的计算机/软件工程/信息管理类本科生。

2. 协同过滤不是“选个算法就行”：用户-物品交互矩阵才是真正的起点

协同过滤（Collaborative Filtering）的本质，是利用群体行为（谁看了什么、打了几分）来预测个体偏好，而非分析电影内容本身。这意味着它的输入不是“科幻片”“爱情片”这类标签，而是结构化的用户-物品评分矩阵。但原始数据（如 MovieLens 的ratings.csv）从来不是现成的矩阵——它是一张长表：每行记录userId,movieId,rating,timestamp。直接用pandas.pivot()强转，会因数据稀疏（百万级用户只评过几十部电影）导致内存爆炸或MemoryError。必须分步构建并验证稀疏表示。

2.1 用 Pandas 清洗原始评分数据，确保 ID 映射无歧义

毕业设计常见陷阱：下载的ratings.csv包含重复评分、异常时间戳、或用户/电影 ID 与movies.csv不匹配。先做最小清洗：

import pandas as pd import numpy as np # 读取原始数据（注意编码，MovieLens 通常为 utf-8） ratings = pd.read_csv('data/ratings.csv', usecols=['userId', 'movieId', 'rating'], # 只取核心三列 dtype={'userId': 'int32', 'movieId': 'int32', 'rating': 'float32'}) movies = pd.read_csv('data/movies.csv', usecols=['movieId', 'title'], dtype={'movieId': 'int32'}) # 去重：同一用户对同一电影多次评分，取最新一次（按原始 timestamp 排序后去重） # 若无 timestamp 列，则直接 drop_duplicates ratings = ratings.drop_duplicates(subset=['userId', 'movieId'], keep='last') # 过滤掉无效评分（MovieLens 评分范围 0.5~5.0，步长 0.5） ratings = ratings[(ratings['rating'] >= 0.5) & (ratings['rating'] <= 5.0) & (ratings['rating'] % 0.5 == 0)] # 验证 movies.csv 中的 movieId 是否全部存在于 ratings 中（避免推荐时查不到标题） valid_movie_ids = set(ratings['movieId'].unique()) movies = movies[movies['movieId'].isin(valid_movie_ids)].copy() print(f"清洗后：{len(ratings)} 条有效评分，覆盖 {len(movies)} 部电影")

提示：drop_duplicates必须指定keep='last'，因为 MovieLens 数据中同一用户对同一电影的多次评分，后一次通常是修正后的更可信值。若你的数据没有timestamp列，此步可省略，但务必检查是否存在重复行。

2.2 构建稀疏用户-物品矩阵：用 scipy.sparse.csr_matrix 替代 dense matrix

pandas.pivot()生成的是稠密 DataFrame，10 万用户 × 1 万电影 = 10^9 个元素，即使全为 0 也占数 GB 内存。正确做法是用scipy.sparse构建 CSR（Compressed Sparse Row）矩阵：

from scipy.sparse import csr_matrix import numpy as np # 获取唯一用户和电影 ID，并映射为连续索引（0-based） user_ids = ratings['userId'].unique() movie_ids = ratings['movieId'].unique() # 创建映射字典：原始 ID → 矩阵索引 user_to_idx = {uid: idx for idx, uid in enumerate(user_ids)} movie_to_idx = {mid: idx for idx, mid in enumerate(movie_ids)} # 将原始评分数据转换为索引坐标和值 rows = ratings['userId'].map(user_to_idx).values cols = ratings['movieId'].map(movie_to_idx).values data = ratings['rating'].values # 构建 CSR 矩阵：shape = (用户数, 电影数) user_item_matrix = csr_matrix((data, (rows, cols)), shape=(len(user_ids), len(movie_ids))) print(f"稀疏矩阵形状：{user_item_matrix.shape}") print(f"非零元素占比：{user_item_matrix.nnz / user_item_matrix.size:.4%}")

2.2.1 为什么必须用 CSR？对比 dense matrix 的灾难性后果

关键在于：协同过滤计算用户相似度时，只关心两个用户共同评过分的电影交集。CSR 矩阵的.dot()和.nonzero()方法天然支持这种稀疏操作，而稠密矩阵会强制遍历所有 10^9 个位置。

2.3 用户相似度计算：皮尔逊相关系数 vs 余弦相似度的实测差异

协同过滤分 User-Based 和 Item-Based。User-Based 计算用户间相似度，Item-Based 计算电影间相似度。毕业设计常被忽略的关键点：相似度公式选择直接影响冷启动鲁棒性和 Top-N 推荐质量。

from sklearn.metrics.pairwise import cosine_similarity, pairwise_distances from scipy.stats import pearsonr def user_pearson_similarity(matrix, user_idx): """计算目标用户与其他用户的皮尔逊相关系数""" target_ratings = matrix[user_idx].toarray().flatten() similarities = [] for i in range(matrix.shape[0]): if i == user_idx: similarities.append(0.0) continue other_ratings = matrix[i].toarray().flatten() # 只计算共同评分过的电影（非零交集） mask = (target_ratings != 0) & (other_ratings != 0) if mask.sum() < 5: # 至少 5 部共同电影才计算，避免噪声 similarities.append(0.0) continue try: corr, _ = pearsonr(target_ratings[mask], other_ratings[mask]) similarities.append(corr if not np.isnan(corr) else 0.0) except: similarities.append(0.0) return np.array(similarities) # 对比余弦相似度（需先中心化，否则对评分尺度敏感） def user_cosine_similarity(matrix, user_idx): """计算目标用户与其他用户的余弦相似度（中心化后）""" # 中心化：减去用户平均分 user_mean = matrix[user_idx].mean() target_centered = matrix[user_idx].toarray().flatten() - user_mean similarities = [] for i in range(matrix.shape[0]): if i == user_idx: similarities.append(0.0) continue other_mean = matrix[i].mean() other_centered = matrix[i].toarray().flatten() - other_mean # 计算余弦相似度 dot_product = np.dot(target_centered, other_centered) norm_target = np.linalg.norm(target_centered) norm_other = np.linalg.norm(other_centered) if norm_target == 0 or norm_other == 0: similarities.append(0.0) else: similarities.append(dot_product / (norm_target * norm_other)) return np.array(similarities)

注意：皮尔逊相关系数对用户评分习惯（如有人习惯打高分、有人习惯打低分）做了归一化，更适合 User-Based CF；余弦相似度未中心化时，会错误地认为“都打 5 分的用户更相似”，而实际上他们可能品味迥异。毕业设计答辩时，若被问“为什么选皮尔逊而不是余弦？”，可答：“因为 MovieLens 用户评分均值差异显著（经统计，标准差达 0.8），皮尔逊能消除个体偏差，提升相似度计算的语义准确性。”

3. 从相似度到推荐结果：Top-K 近邻筛选与加权预测的完整实现

有了用户相似度向量，下一步是选出最相似的 K 个邻居（K 通常取 10~30），再用他们的评分加权预测目标用户对未评分电影的喜好。这一步极易出错：直接取np.argsort(similarities)[-K:]会包含相似度为负的用户（说明品味相反），导致推荐结果恶化。

3.1 安全的 Top-K 近邻筛选：过滤负相似度 + 处理邻居不足

def get_top_k_neighbors(similarities, k=20, min_similarity=0.1): """ 获取相似度大于阈值的 Top-K 邻居索引 :param similarities: 相似度数组，长度 = 用户总数 :param k: 目标邻居数 :param min_similarity: 最小相似度阈值（避免引入反向偏好） :return: (neighbor_indices, neighbor_similarities) 元组 """ # 过滤掉相似度 <= min_similarity 的用户（包括负值） valid_mask = similarities > min_similarity valid_indices = np.where(valid_mask)[0] valid_scores = similarities[valid_mask] if len(valid_indices) == 0: return np.array([]), np.array([]) # 按相似度降序排列，取前 k 个 top_k_idx = np.argsort(valid_scores)[-k:][::-1] # 降序 neighbor_indices = valid_indices[top_k_idx] neighbor_similarities = valid_scores[top_k_idx] return neighbor_indices, neighbor_similarities # 示例：为目标用户 0 计算邻居 user_idx = 0 pearson_sim = user_pearson_similarity(user_item_matrix, user_idx) neighbors, sim_scores = get_top_k_neighbors(pearson_sim, k=15, min_similarity=0.2) print(f"用户 {user_idx} 的 Top-15 邻居（相似度 > 0.2）：{len(neighbors)} 个")

3.2 加权预测：用邻居评分预测目标用户对某部电影的评分

预测公式：
$$\hat{r}{u,i} = \bar{r}u + \frac{\sum{v \in N(u)} sim(u,v) \cdot (r{v,i} - \bar{r}v)}{\sum{v \in N(u)} |sim(u,v)|}$$
其中 $\bar{r}u$ 是用户 u 的平均分，$N(u)$ 是 u 的邻居集合，$r{v,i}$ 是邻居 v 对电影 i 的评分。

def predict_rating(user_item_matrix, user_idx, movie_idx, neighbors, sim_scores): """ 预测用户 user_idx 对电影 movie_idx 的评分 :param user_item_matrix: CSR 矩阵 :param user_idx: 目标用户索引 :param movie_idx: 目标电影索引 :param neighbors: 邻居用户索引数组 :param sim_scores: 对应邻居相似度数组 :return: 预测评分（float），若无法预测则返回 None """ # 获取目标用户平均分 user_ratings = user_item_matrix[user_idx].toarray().flatten() user_mean = user_ratings[user_ratings != 0].mean() if np.any(user_ratings != 0) else 0.0 numerator = 0.0 denominator = 0.0 for i, neighbor_idx in enumerate(neighbors): # 获取邻居对该电影的评分 neighbor_rating = user_item_matrix[neighbor_idx, movie_idx] if neighbor_rating == 0: # 邻居未评过分，跳过 continue # 获取邻居平均分 neighbor_ratings = user_item_matrix[neighbor_idx].toarray().flatten() neighbor_mean = neighbor_ratings[neighbor_ratings != 0].mean() if np.any(neighbor_ratings != 0) else 0.0 # 累加分子和分母 numerator += sim_scores[i] * (neighbor_rating - neighbor_mean) denominator += abs(sim_scores[i]) if denominator == 0: return None predicted = user_mean + numerator / denominator # 截断到合法评分范围 [0.5, 5.0] return np.clip(predicted, 0.5, 5.0) # 预测用户 0 对电影 5 的评分 pred = predict_rating(user_item_matrix, user_idx=0, movie_idx=5, neighbors=neighbors, sim_scores=sim_scores) print(f"预测用户 0 对电影 5 的评分：{pred:.2f}")

3.2.1 关键参数表：毕业设计中必须明确写出的超参数及其影响

3.3 生成 Top-N 推荐列表：排除已评分电影 + 按预测分排序

最终输出给用户的不是单个预测分，而是 N 部最可能喜欢的电影。必须排除用户已评过分的电影，并确保推荐结果可解释（附上预测分和电影标题）：

def get_top_n_recommendations(user_item_matrix, user_idx, movies_df, neighbors, sim_scores, n=10): """ 为目标用户生成 Top-N 推荐列表 :param movies_df: 包含 movieId 和 title 的 DataFrame :param n: 推荐数量 :return: list of tuples (movieId, title, predicted_rating) """ # 获取用户已评分的电影索引 user_rated = user_item_matrix[user_idx].toarray().flatten().nonzero()[0] # 遍历所有未评分电影，计算预测分 predictions = [] for movie_idx in range(user_item_matrix.shape[1]): if movie_idx in user_rated: continue pred = predict_rating(user_item_matrix, user_idx, movie_idx, neighbors, sim_scores) if pred is not None: # 获取原始 movieId（通过 movie_to_idx 反查） original_movie_id = movies_df.iloc[movie_idx]['movieId'] title = movies_df.iloc[movie_idx]['title'] predictions.append((original_movie_id, title, pred)) # 按预测分降序排列，取 Top-N predictions.sort(key=lambda x: x[2], reverse=True) return predictions[:n] # 为用户 0 生成 Top-5 推荐 top5 = get_top_n_recommendations(user_item_matrix, user_idx=0, movies_df=movies, neighbors=neighbors, sim_scores=sim_scores, n=5) print("\n用户 0 的 Top-5 推荐：") for i, (mid, title, score) in enumerate(top5, 1): print(f"{i}. {title} (预测分: {score:.2f})")

提示：movies_df.iloc[movie_idx]能正确获取标题，前提是movies_df的行顺序与movie_to_idx映射一致。若movies.csv中movieId未按升序排列，需先执行movies = movies.sort_values('movieId').reset_index(drop=True)。

4. 模型评估不是“print RMSE”：用留一法（Leave-One-Out）模拟真实场景

毕业设计答辩时，老师常问：“你的推荐准不准？怎么证明？” 仅用训练集上的 RMSE（均方根误差）是无效的——它衡量拟合能力，而非推荐效果。必须采用留一法（Leave-One-Out）：对每个用户，随机隐藏其一条评分作为测试集，其余用于训练，再看模型能否把这个隐藏分准确预测出来。这是推荐系统领域公认的 baseline 评估方法。

4.1 实现留一法评估：构建 train/test split 并计算 Hit Rate

from sklearn.model_selection import train_test_split def leave_one_out_split(ratings_df, test_size=0.2, random_state=42): """ 为每个用户留出一条评分作为测试集 :return: (train_df, test_df) 两个 DataFrame """ # 对每个用户，随机选一条记录作为测试 test_list = [] train_list = [] for user_id in ratings_df['userId'].unique(): user_ratings = ratings_df[ratings_df['userId'] == user_id] if len(user_ratings) < 2: # 只有一条评分的用户，全部放入训练集 train_list.append(user_ratings) continue # 随机选一条作为测试 test_sample = user_ratings.sample(n=1, random_state=random_state) train_sample = user_ratings.drop(test_sample.index) test_list.append(test_sample) train_list.append(train_sample) train_df = pd.concat(train_list, ignore_index=True) test_df = pd.concat(test_list, ignore_index=True) return train_df, test_df # 执行留一法分割 train_ratings, test_ratings = leave_one_out_split(ratings) print(f"留一法分割：训练集 {len(train_ratings)} 条，测试集 {len(test_ratings)} 条") # 用训练集重建用户-物品矩阵 # （此处复用 2.1 和 2.2 的清洗与矩阵构建逻辑，略） # ... # 得到 train_user_item_matrix, train_user_to_idx, train_movie_to_idx

4.2 计算 Hit Rate@10：推荐列表中是否包含用户隐藏的真实评分电影

RMSE 只反映预测分与真实分的数值差距，而Hit Rate@N衡量推荐是否命中用户真实兴趣——这才是推荐系统的终极目标。

def hit_rate_at_k(model_matrix, train_user_to_idx, train_movie_to_idx, test_df, movies_df, k=10, similarity_func=user_pearson_similarity): """ 计算 Hit Rate@K :param test_df: 测试集 DataFrame，含 userId, movieId, rating :return: float, Hit Rate """ hits = 0 total = len(test_df) for _, row in test_df.iterrows(): user_id = row['userId'] true_movie_id = row['movieId'] # 检查用户 ID 和电影 ID 是否在训练集中存在 if user_id not in train_user_to_idx or true_movie_id not in train_movie_to_idx: continue user_idx = train_user_to_idx[user_id] movie_idx = train_movie_to_idx[true_movie_id] # 获取该用户的 Top-K 推荐电影 ID 列表 similarities = similarity_func(model_matrix, user_idx) neighbors, sim_scores = get_top_k_neighbors(similarities, k=20, min_similarity=0.2) recommendations = get_top_n_recommendations( model_matrix, user_idx, movies_df, neighbors, sim_scores, n=k ) # 检查真实电影是否在推荐列表中（按 movieId 匹配） recommended_movie_ids = [rec[0] for rec in recommendations] if true_movie_id in recommended_movie_ids: hits += 1 return hits / total if total > 0 else 0.0 # 计算 Hit Rate@10 hr10 = hit_rate_at_k(train_user_item_matrix, train_user_to_idx, train_movie_to_idx, test_ratings, movies) print(f"Hit Rate@10: {hr10:.3f} ({int(hr10*100)}%)")

4.2.1 毕业设计必须呈现的评估结果对比表

注意：Item-Based CF 对冷启动用户更友好（新用户只要评过一部电影，就能基于该电影找到相似电影），而 User-Based 在新用户上几乎失效。毕业设计若强调“解决冷启动”，应优先展示 Item-Based 结果；若侧重“用户兴趣挖掘深度”，则突出 User-Based 的 Hit Rate。

5. 毕业设计交付物 checklist：从源码到答辩 PPT 的硬性要求

一份能通过答辩的“Python 基于协同过滤推荐算法的电影推荐系统”，绝不仅是python app.py跑起来。评审老师会逐项查验以下交付物，缺一不可：

5.1 源码结构必须包含的 5 个核心目录与文件

5.2 答辩 PPT 中必须出现的 3 张技术图

1. 用户-物品交互矩阵示意图：用 5×5 小矩阵展示稀疏性（标出非零值位置），箭头指向“CSR 存储格式”，旁注“节省 99.2% 内存”。
2. Top-K 近邻筛选流程图：原始相似度向量 → 过滤 min_similarity → argsort → 取 Top-K → 加权预测，每步标注 Python 函数名（如get_top_k_neighbors()）。
3. 留一法评估对比柱状图：X 轴为User-Based,Item-Based,Hybrid，Y 轴为Hit Rate@10，柱子上标具体数值（如32.6%），并用星号标出最优结果。

5.3 防止答辩翻车的 4 个硬编码检查

# ✅ 正确：路径使用 os.path.join，兼容 Windows/Linux import os data_path = os.path.join('data', 'ratings.csv') # ❌ 错误：硬编码反斜杠（Windows）或正斜杠（Linux） # data_path = 'data\\ratings.csv' # Windows only # data_path = 'data/ratings.csv' # Linux only # ✅ 正确：模型保存用 joblib，支持大数组 from joblib import dump, load dump(model, 'models/user_cf_model.pkl') # ❌ 错误：用 pickle 保存稀疏矩阵（可能失败） # import pickle # with open('models/model.pkl', 'wb') as f: # pickle.dump(model, f) # ✅ 正确：Web 界面端口可配置 import argparse parser = argparse.ArgumentParser() parser.add_argument('--port', type=int, default=5000) args = parser.parse_args() app.run(port=args.port) # ❌ 错误：端口写死 # app.run(port=5000)

提示：答辩前用python -m py_compile src/*.py编译所有 Python 文件，确认无语法错误；用pip list --outdated检查依赖包是否过时，scikit-surprise建议固定为1.1.3（兼容性最好），避免surprise新版 API 变更导致Dataset.load_from_df报错。

最后，把requirements.txt中的scikit-surprise==1.1.3、pandas==1.3.5、scipy==1.7.3这些精确版本号写进答辩 PPT 的“技术栈”页——这比说“用了 Python”有力得多。

本文还有配套的精品资源，点击获取