Python+Django实现协同过滤电影推荐系统

1. 项目概述

这个基于Python+Django的协同过滤算法电影推荐系统，是我在开发实践中总结的一套完整的推荐系统解决方案。不同于传统的电影评分网站，这个系统能够根据用户的历史行为和偏好，自动推荐可能感兴趣的电影，实现真正的个性化推荐。

推荐系统在当今互联网应用中扮演着越来越重要的角色。根据我的开发经验，一个好的推荐系统能够显著提升用户体验和平台粘性。以电影推荐为例，用户不再需要花费大量时间在茫茫片库中寻找自己喜欢的电影，系统会根据算法自动匹配适合的内容。

2. 技术选型与架构设计

2.1 后端框架选择

选择Django作为后端框架主要基于以下几个考虑：

1. Django提供了完整的MVT架构，内置ORM、模板引擎和路由系统，开发效率高
2. 自带Admin后台管理系统，方便数据管理和维护
3. 丰富的第三方库支持，特别是对机器学习算法的集成
4. 完善的文档和活跃的社区，遇到问题容易找到解决方案

在实际开发中，我发现Django的ORM特别适合快速构建数据模型，通过简单的Python类定义就能自动生成数据库表结构，大大减少了SQL编写的工作量。

2.2 数据库设计

系统使用MySQL作为主数据库，主要包含以下几张核心表：

1. 用户表(User)：

   • 存储用户基本信息
   • 包含用户ID、用户名、密码(加密存储)、注册时间等字段

2. 电影表(Movie)：

   • 存储电影基本信息
   • 包含电影ID、标题、类型、年份、评分、封面URL等字段

3. 评分表(Rating)：

   • 记录用户对电影的评分
   • 包含用户ID、电影ID、评分值、评分时间等字段
   • 建立用户和电影之间的多对多关系

4. 用户行为表(Behavior)：

   • 记录用户的浏览、收藏等行为
   • 包含用户ID、电影ID、行为类型、时间戳等字段

提示：在实际项目中，建议对频繁查询的字段建立索引，特别是用户ID和电影ID这类经常用于关联查询的字段。

2.3 前端技术选型

虽然项目描述中提到Vue，但在实际电影推荐系统中，我建议采用以下技术组合：

1. 基础框架：Vue.js 3.x + Vue Router + Vuex
2. UI组件库：Element Plus 或 Ant Design Vue
3. 可视化图表：ECharts 或 D3.js
4. 构建工具：Vite

这种组合的优势在于：

• Vue 3的Composition API使代码组织更清晰
• Element Plus提供了丰富的现成组件，加速开发
• ECharts可以很好地展示推荐结果和数据分析

3. 协同过滤算法实现

3.1 算法原理

协同过滤算法主要分为两类：

1. 基于用户的协同过滤(User-based CF)：

   • 找到与目标用户兴趣相似的其他用户
   • 将这些相似用户喜欢的、且目标用户未看过的电影推荐给目标用户

2. 基于物品的协同过滤(Item-based CF)：

   • 计算电影之间的相似度
   • 找出目标用户喜欢的电影，然后推荐与这些电影相似的其他电影

在实际应用中，我发现Item-based CF通常表现更好，因为：

• 电影之间的相似度比用户之间的相似度更稳定
• 计算量相对较小，适合电影数量多但用户评分数据稀疏的场景

3.2 相似度计算

相似度计算是协同过滤的核心，常用的方法有：

1. 余弦相似度(Cosine Similarity)：

   python复制def cosine_similarity(vec1, vec2):
       dot_product = np.dot(vec1, vec2)
       norm1 = np.linalg.norm(vec1)
       norm2 = np.linalg.norm(vec2)
       return dot_product / (norm1 * norm2)
   

2. 皮尔逊相关系数(Pearson Correlation)：

   python复制def pearson_similarity(vec1, vec2):
       return np.corrcoef(vec1, vec2)[0, 1]
   

3. 调整余弦相似度(Adjusted Cosine Similarity)：

   • 考虑用户评分偏置
   • 先减去用户平均评分，再计算余弦相似度

经过多次实验，我发现调整余弦相似度在实际应用中效果最好，因为它考虑了不同用户评分标准的差异。

3.3 算法优化

在实际开发中，我总结了几点优化经验：

1. 数据稀疏性问题：

   • 引入隐语义模型(LFM)补充协同过滤
   • 使用矩阵分解技术(如SVD)降维

2. 冷启动问题：

   • 新用户：采用基于内容的推荐或热门推荐
   • 新电影：使用电影元数据(类型、导演等)计算相似度

3. 实时性优化：

   • 离线计算相似度矩阵，定期更新
   • 在线部分只做轻量级计算

4. 多样性保障：

   • 在推荐结果中混入不同类型电影
   • 使用聚类算法确保推荐覆盖面

4. 系统实现细节

4.1 Django模型定义

python复制from django.db import models
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    GENDER_CHOICES = (
        ('M', 'Male'),
        ('F', 'Female'),
        ('O', 'Other'),
    )
    gender = models.CharField(max_length=1, choices=GENDER_CHOICES, blank=True)
    age = models.IntegerField(null=True, blank=True)
    register_date = models.DateTimeField(auto_now_add=True)

class Movie(models.Model):
    title = models.CharField(max_length=200)
    genres = models.CharField(max_length=100)
    year = models.IntegerField()
    rating = models.FloatField(default=0)
    poster_url = models.URLField(max_length=500, blank=True)
    
    def __str__(self):
        return f"{self.title} ({self.year})"

class Rating(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    movie = models.ForeignKey(Movie, on_delete=models.CASCADE)
    rating = models.FloatField()
    timestamp = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        unique_together = ('user', 'movie')

4.2 推荐引擎实现

python复制import numpy as np
from collections import defaultdict
from django.db.models import Count, Avg
from .models import Rating, Movie

class Recommender:
    def __init__(self):
        self.user_ratings = None
        self.movie_similarity = None
    
    def load_data(self):
        """加载评分数据并构建用户-电影评分矩阵"""
        ratings = Rating.objects.all().values('user_id', 'movie_id', 'rating')
        
        self.user_ratings = defaultdict(dict)
        for r in ratings:
            self.user_ratings[r['user_id']][r['movie_id']] = r['rating']
    
    def calculate_similarity(self):
        """计算电影之间的相似度矩阵"""
        # 构建倒排表：电影->用户评分
        movie_users = defaultdict(dict)
        for user, movies in self.user_ratings.items():
            for movie, rating in movies.items():
                movie_users[movie][user] = rating
        
        # 计算电影相似度
        self.movie_similarity = defaultdict(dict)
        movies = list(movie_users.keys())
        
        for i in range(len(movies)):
            for j in range(i+1, len(movies)):
                m1 = movies[i]
                m2 = movies[j]
                
                # 获取同时对两个电影评分的用户
                common_users = set(movie_users[m1].keys()) & set(movie_users[m2].keys())
                
                if len(common_users) < 5:  # 共同评分用户太少则跳过
                    continue
                
                # 计算调整余弦相似度
                vec1 = []
                vec2 = []
                for u in common_users:
                    vec1.append(movie_users[m1][u])
                    vec2.append(movie_users[m2][u])
                
                similarity = np.corrcoef(vec1, vec2)[0, 1]
                if np.isnan(similarity):
                    similarity = 0
                
                self.movie_similarity[m1][m2] = similarity
                self.movie_similarity[m2][m1] = similarity
    
    def recommend_for_user(self, user_id, top_n=10):
        """为用户生成推荐"""
        if user_id not in self.user_ratings:
            # 新用户，返回热门电影
            return self.get_popular_movies(top_n)
        
        user_ratings = self.user_ratings[user_id]
        scores = defaultdict(float)
        
        # 对用户评分过的每个电影
        for movie_id, rating in user_ratings.items():
            # 找到相似的电影
            for similar_movie, similarity in self.movie_similarity.get(movie_id, {}).items():
                if similar_movie not in user_ratings:  # 用户没看过的
                    scores[similar_movie] += similarity * (rating - 2.5)  # 减去中性评分
        
        # 按得分排序
        recommended = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:top_n]
        return [movie_id for movie_id, score in recommended]
    
    def get_popular_movies(self, top_n=10):
        """获取热门电影(用于冷启动)"""
        return Movie.objects.annotate(
            rating_count=Count('rating')
        ).order_by('-rating_count', '-rating')[:top_n]

4.3 视图层实现

python复制from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from .recommender import Recommender

@login_required
def recommend_view(request):
    recommender = Recommender()
    recommender.load_data()
    recommender.calculate_similarity()
    
    user_id = request.user.id
    movie_ids = recommender.recommend_for_user(user_id, top_n=10)
    
    recommended_movies = Movie.objects.filter(id__in=movie_ids)
    
    context = {
        'recommended_movies': recommended_movies,
        'user': request.user
    }
    return render(request, 'recommendations.html', context)

5. 系统部署与优化

5.1 性能优化技巧

1. 缓存策略：

   • 使用Redis缓存热门推荐结果
   • 为每个用户缓存个性化推荐，设置合理过期时间

2. 异步计算：

   • 使用Celery异步更新相似度矩阵
   • 将耗时计算任务放到后台执行

3. 数据库优化：

   • 为常用查询字段添加索引
   • 使用select_related/prefetch_related减少查询次数

4. 算法优化：

   • 使用近似最近邻(ANN)算法加速相似度计算
   • 对大数据集采用采样方法

5.2 部署方案

推荐的生产环境部署方案：

1. Web服务器：Nginx + Gunicorn
2. 数据库：MySQL主从复制
3. 缓存：Redis集群
4. 任务队列：Celery + RabbitMQ
5. 监控：Prometheus + Grafana

部署步骤示例：

bash复制# 安装依赖
pip install -r requirements.txt

# 数据库迁移
python manage.py migrate

# 收集静态文件
python manage.py collectstatic

# 启动Gunicorn
gunicorn --workers 4 --bind 0.0.0.0:8000 project.wsgi:application

# 启动Celery worker
celery -A project worker -l info

6. 常见问题与解决方案

6.1 冷启动问题

问题描述：新用户或新电影缺乏足够的行为数据，难以生成准确推荐。

解决方案：

1. 对于新用户：

   • 在注册时收集基本信息(年龄、性别、偏好类型等)
   • 初期采用基于内容的推荐或热门推荐
   • 随着用户行为积累逐步切换到协同过滤

2. 对于新电影：

   • 利用电影元数据(类型、导演、演员等)计算内容相似度
   • 与已有电影建立关联
   • 在推荐中适当提高新电影的曝光率

6.2 数据稀疏性问题

问题描述：用户-电影评分矩阵非常稀疏，导致相似度计算不准确。

解决方案：

1. 引入隐语义模型(LFM)：

   • 使用矩阵分解技术填补缺失值
   • 发现潜在的特征维度

2. 采用基于模型的协同过滤：

   • 使用ALS(交替最小二乘法)优化
   • 实现更稳健的推荐

3. 混合推荐策略：

   • 结合协同过滤和基于内容的推荐
   • 根据数据稀疏程度动态调整权重

6.3 实时性挑战

问题描述：用户最新行为无法立即影响推荐结果。

解决方案：

1. 分层推荐架构：

   • 离线层：定期(如每天)全量计算
   • 近线层：每小时增量更新
   • 在线层：实时响应用户行为

2. 实时特征工程：

   • 记录用户最近浏览、搜索行为
   • 在推荐时给予更高权重

3. 流式计算：

   • 使用Kafka等消息队列处理用户行为事件
   • 采用Flink/Spark Streaming实时计算

7. 项目扩展方向

1. 多算法融合：

   • 结合协同过滤、内容推荐和深度学习模型
   • 使用集成学习优化推荐效果

2. 上下文感知推荐：

   • 考虑时间、地点、设备等上下文信息
   • 实现更精准的场景化推荐

3. 可解释性推荐：

   • 向用户解释推荐理由
   • 如"因为你喜欢《盗梦空间》，所以推荐《星际穿越》"

4. A/B测试框架：

   • 实现不同算法的在线对比
   • 基于用户反馈持续优化

5. 跨域推荐：

   • 结合用户在其他领域的行为数据
   • 如根据音乐偏好推荐电影

在实际开发中，我发现推荐系统是一个需要持续迭代优化的工程。除了算法本身，数据质量、系统架构和用户体验都至关重要。建议从简单实现开始，逐步添加复杂功能，通过A/B测试验证效果，最终构建一个高效、稳定的推荐系统。