Python电影推荐系统：Django+Vue混合算法实践

1. 项目概述与核心价值

这个基于Python的个性化电影推荐系统是我在指导计算机专业学生毕业设计时经常采用的经典案例。它完美融合了爬虫技术、数据处理、推荐算法和Web开发等多个热门技术方向，特别适合作为本科或研究生阶段的综合实践项目。

系统采用B/S架构，前端使用Vue.js构建响应式界面，后端基于Django框架开发，数据存储选用MySQL关系型数据库。整个系统的技术栈选择考虑了以下几个关键因素：

• Django作为Python生态中最成熟的Web框架，提供了完善的ORM、模板引擎和Admin后台，能快速搭建功能完备的后端服务
• Vue.js的组件化开发模式与Django REST framework配合良好，适合构建现代化的前后端分离应用
• MySQL作为关系型数据库，在保证事务特性的同时，也能满足中等规模数据存储需求

提示：对于毕业设计项目，建议选择技术文档丰富、社区活跃的技术栈，这样在开发过程中遇到问题更容易找到解决方案。

系统的核心创新点在于：

1. 多源数据融合：不仅从豆瓣等公开平台获取电影元数据，还通过用户行为日志构建动态兴趣模型
2. 混合推荐策略：结合基于内容的推荐和协同过滤算法，既考虑电影本身的特征，也利用用户群体的行为模式
3. 实时交互设计：用户评分、收藏等操作会即时影响推荐结果，形成正向反馈循环

2. 系统架构设计详解

2.1 三层架构实现

系统采用经典的三层架构设计，各层职责明确：

2.1.1 视图层(View)

• 技术栈：Vue 3 + Element Plus + ECharts
• 核心组件：
  • 电影卡片组件：展示电影海报、评分等基本信息
  • 推荐面板：根据用户兴趣动态生成推荐列表
  • 可视化看板：使用ECharts展示电影数据统计图表
• 关键实现：

vue复制<template>
  <div class="movie-card">
    <el-image :src="movie.poster" fit="cover"></el-image>
    <div class="movie-info">
      <h3>{{ movie.title }}</h3>
      <el-rate v-model="movie.rating" disabled></el-rate>
      <el-button @click="handleLike">收藏</el-button>
    </div>
  </div>
</template>

<script>
export default {
  props: ['movie'],
  methods: {
    handleLike() {
      this.$emit('on-like', this.movie.id)
    }
  }
}
</script>

2.1.2 控制层(Controller)

• 技术栈：Django REST framework
• 核心功能：
  • 用户认证：JWT令牌管理
  • 推荐引擎：封装推荐算法为API服务
  • 行为日志：记录用户操作轨迹
• 典型API实现：

python复制from rest_framework.views import APIView
from rest_framework.response import Response

class RecommendAPI(APIView):
    def get(self, request):
        user_id = request.user.id
        # 获取混合推荐结果
        content_based = content_based_recommend(user_id)
        cf = collaborative_filtering(user_id)
        hybrid = hybrid_recommend(content_based, cf)
        return Response({
            'recommendations': hybrid,
            'timestamp': time.time()
        })

2.1.3 模型层(Model)

• 数据库设计要点：
  • 电影表：存储电影元数据（标题、类型、导演等）
  • 用户表：用户基本信息和偏好标签
  • 行为表：记录用户评分、收藏等操作
• Django模型示例：

python复制from django.db import models

class Movie(models.Model):
    douban_id = models.CharField(max_length=20, unique=True)
    title = models.CharField(max_length=200)
    directors = models.CharField(max_length=300)
    casts = models.TextField()
    genres = models.JSONField()
    rating = models.FloatField()
    
    class Meta:
        db_table = 'movie'
        indexes = [
            models.Index(fields=['rating']),
            models.Index(fields=['genres'], name='genres_idx')
        ]

2.2 数据流向设计

系统数据流遵循以下路径：

1. 爬虫定期抓取豆瓣电影数据
2. 数据清洗后存入MySQL
3. 用户行为通过前端收集并发送到Django
4. 推荐服务综合静态数据和动态行为生成推荐列表
5. 推荐结果通过API返回前端展示

注意：在实际部署时，建议将爬虫服务与Web服务分离，避免爬虫任务影响用户请求响应时间。

3. 数据采集与处理实现

3.1 爬虫系统构建

3.1.1 Scrapy爬虫配置

爬虫项目采用Scrapy框架，关键配置如下：

python复制# settings.py
BOT_NAME = 'movie_spider'
USER_AGENT = 'Mozilla/5.0 (compatible; MovieRecBot/1.0)'
ROBOTSTXT_OBEY = False
DOWNLOAD_DELAY = 2
CONCURRENT_REQUESTS = 16
ITEM_PIPELINES = {
    'pipelines.MongoDBPipeline': 300,
}

3.1.2 分布式爬虫实现

为提高爬取效率，我们使用Scrapy-Redis构建分布式爬虫：

1. 安装依赖：pip install scrapy-redis
2. 修改爬虫类：

python复制from scrapy_redis.spiders import RedisSpider

class DoubanSpider(RedisSpider):
    name = 'douban'
    redis_key = 'douban:start_urls'
    
    def parse(self, response):
        # 解析逻辑保持不变
        yield item

3. 启动Redis服务器作为任务队列

3.2 数据清洗策略

3.2.1 缺失值处理进阶技巧

针对不同类型字段采用差异化处理：

python复制def clean_movie_data(df):
    # 数值型字段：使用KNN填充
    from sklearn.impute import KNNImputer
    num_cols = ['rating', 'duration']
    imputer = KNNImputer(n_neighbors=5)
    df[num_cols] = imputer.fit_transform(df[num_cols])
    
    # 文本型字段：多重填充策略
    df['directors'] = df['directors'].fillna('未知导演')
    
    # 分类字段：构建"其他"类别
    genre_mode = df['genres'].mode()[0]
    df['genres'] = df['genres'].apply(
        lambda x: genre_mode if pd.isna(x) else x)
    
    return df

3.2.2 数据质量验证

清洗完成后进行数据质量检查：

python复制def validate_data(df):
    # 检查评分范围
    assert df['rating'].between(1, 10).all()
    
    # 检查日期有效性
    from datetime import datetime
    current_year = datetime.now().year
    assert df['year'].between(1900, current_year).all()
    
    # 检查唯一性
    assert df['douban_id'].nunique() == len(df)

4. 推荐算法核心实现

4.1 混合推荐策略

系统采用三种推荐算法组合：

4.1.1 基于内容的推荐

python复制from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def content_based_recommend(movie_id, top_n=5):
    # 获取所有电影数据
    movies = Movie.objects.all().values()
    df = pd.DataFrame.from_records(movies)
    
    # 构建特征矩阵
    tfidf = TfidfVectorizer(stop_words='english')
    tfidf_matrix = tfidf.fit_transform(df['genres'] + ' ' + df['directors'])
    
    # 计算相似度
    cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)
    
    # 获取推荐
    idx = df[df['id']==movie_id].index[0]
    sim_scores = list(enumerate(cosine_sim[idx]))
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
    sim_scores = sim_scores[1:top_n+1]
    movie_indices = [i[0] for i in sim_scores]
    
    return df.iloc[movie_indices]

4.1.2 协同过滤实现

python复制from surprise import Dataset, KNNBasic
from surprise.model_selection import train_test_split

def collaborative_filtering(user_id, top_n=5):
    # 加载评分数据
    ratings = Rating.objects.all().values()
    df = pd.DataFrame.from_records(ratings)
    
    # 使用Surprise库构建模型
    reader = Reader(rating_scale=(1, 5))
    data = Dataset.load_from_df(df[['user_id', 'movie_id', 'rating']], reader)
    trainset, testset = train_test_split(data, test_size=0.25)
    
    # 训练KNN模型
    sim_options = {'name': 'cosine', 'user_based': False}
    algo = KNNBasic(sim_options=sim_options)
    algo.fit(trainset)
    
    # 获取推荐
    testset = [[user_id, movie.id, 4.] for movie in Movie.objects.all()]
    predictions = algo.test(testset)
    predictions.sort(key=lambda x: x.est, reverse=True)
    
    return [pred.iid for pred in predictions[:top_n]]

4.1.3 混合推荐算法

python复制def hybrid_recommend(user_id, top_n=10):
    # 获取用户最近评分的电影
    last_rated = Rating.objects.filter(
        user_id=user_id
    ).order_by('-timestamp').first()
    
    if last_rated:
        # 基于内容推荐
        content_rec = content_based_recommend(last_rated.movie_id, top_n//2)
        # 协同过滤推荐
        cf_rec = collaborative_filtering(user_id, top_n//2)
        # 合并结果
        return list(set(content_rec + cf_rec))
    else:
        # 新用户返回热门电影
        return Movie.objects.order_by('-rating')[:top_n]

4.2 实时推荐优化

为提高推荐实时性，系统采用以下策略：

1. 用户兴趣衰减模型：

python复制def get_user_interest(user_id):
    # 获取用户所有行为
    actions = UserAction.objects.filter(user_id=user_id)
    
    # 计算带时间衰减的权重
    now = time.time()
    interest = defaultdict(float)
    for action in actions:
        # 时间衰减因子：最近行为权重更高
        time_decay = 1 / (1 + math.log1p(now - action.timestamp))
        interest[action.movie_id] += action.weight * time_decay
    
    return dict(interest)

2. 缓存策略：

python复制from django.core.cache import cache

def get_recommendations(user_id):
    cache_key = f'rec_{user_id}'
    result = cache.get(cache_key)
    if not result:
        result = hybrid_recommend(user_id)
        cache.set(cache_key, result, timeout=3600)  # 缓存1小时
    return result

5. 系统部署与性能优化

5.1 生产环境部署

推荐使用Docker Compose部署整套系统：

yaml复制version: '3'

services:
  web:
    build: .
    command: gunicorn movie_rec.wsgi:application --bind 0.0.0.0:8000
    volumes:
      - .:/code
    ports:
      - "8000:8000"
    depends_on:
      - redis
      - db

  redis:
    image: redis:alpine
    ports:
      - "6379:6379"

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: movie_rec
    volumes:
      - db_data:/var/lib/mysql
    ports:
      - "3306:3306"

volumes:
  db_data:

5.2 性能优化技巧

1. 数据库优化：

python复制# 使用select_related减少查询次数
movies = Movie.objects.select_related('director').filter(rating__gt=8)

# 添加适当索引
class Meta:
    indexes = [
        models.Index(fields=['rating']),
        models.Index(fields=['release_date']),
    ]

2. 前端性能优化：

javascript复制// 使用虚拟滚动优化长列表渲染
<template>
  <RecycleScroller
    class="movie-list"
    :items="movies"
    :item-size="200"
    key-field="id"
  >
    <template v-slot="{ item }">
      <MovieCard :movie="item" />
    </template>
  </RecycleScroller>
</template>

3. 异步任务处理：
   对于爬虫等耗时任务，使用Celery异步处理：

python复制@app.task
def run_spider():
    os.system('scrapy crawl douban')
    
# 定时任务配置
CELERY_BEAT_SCHEDULE = {
    'run-spider-every-night': {
        'task': 'tasks.run_spider',
        'schedule': crontab(hour=3, minute=0),
    },
}

6. 项目扩展方向

这个基础系统可以进一步扩展为：

1. 多模态推荐：引入电影海报的视觉特征分析

python复制# 使用预训练CNN提取视觉特征
from tensorflow.keras.applications import VGG16

model = VGG16(weights='imagenet', include_top=False)

def extract_features(image_path):
    img = load_img(image_path, target_size=(224, 224))
    img_array = img_to_array(img)
    expanded = np.expand_dims(img_array, axis=0)
    preprocessed = preprocess_input(expanded)
    features = model.predict(preprocessed)
    return features.flatten()

2. 知识图谱整合：
   构建电影-演员-导演关系图谱，实现更智能的推荐

3. A/B测试框架：

python复制def recommend_with_abtest(user_id):
    if user_id % 2 == 0:
        # A组：传统算法
        return hybrid_recommend(user_id)
    else:
        # B组：新算法
        return deep_learning_recommend(user_id)

4. 移动端适配：
   使用Vue Native或Flutter开发跨平台移动应用

这个项目从技术选型到算法实现都体现了现代Web开发的典型模式，既适合作为学习项目掌握全栈开发技能，也具备商业应用的潜力。在实际开发过程中，我建议学生重点关注数据质量管理和推荐算法优化这两个核心环节，它们往往决定了推荐系统的最终效果。