基于Django与协同过滤算法:从零构建电影推荐系统实战

简介:这是一套面向Python与Web开发初学者及进阶学习者的电影推荐系统实战项目源码,聚焦协同过滤算法在Django框架下的工程化落地,适用于课程设计、毕业设计或推荐系统入门实践。资源共725个文件,总大小37.65MB,涵盖39个核心Python后端逻辑文件(含数据处理、推荐算法与Django视图)、41个Vue前端组件、164个JavaScript交互脚本、53个CSS样式文件及大量SVG图标与静态图片资源,完整呈现前后端分离架构下的推荐系统开发全流程。已有447人学习下载,项目包含可直接运行的安装/启动/构建批处理脚本(.bat),并保留了.bak备份文件与多版本静态资源,便于理解迭代过程与调试逻辑;目录结构清晰,模块划分明确,特别适合通过真实业务场景掌握Django ORM、MySQL集成、用户行为建模及前端动态渲染等关键技术点。

1. 项目概述与核心价值

最近几年,无论是刷短视频还是逛电商,你肯定没少被“猜你喜欢”骚扰过。这背后,推荐系统功不可没。今天,我们不聊那些大厂的复杂架构,就从一个开发者最务实、最接地气的角度出发,聊聊如何亲手搭建一个属于自己的电影推荐系统。这个项目,我选择用 Django 和 Python 来实现,原因很简单:Django是Python生态里“开箱即用”的典范,它能帮你快速搞定用户认证、后台管理这些繁琐但必需的模块,让你能把精力真正集中在推荐算法的核心逻辑上。而Python,作为数据科学和机器学习领域的“头号玩家”,其丰富的库(像pandas, numpy, scikit-learn)让实现各种推荐算法变得像搭积木一样简单。

这个项目适合谁呢?如果你是刚学完Python和Django基础,想找个有挑战性的综合项目来练手,那它再合适不过了。它能让你把Web开发、数据库设计、算法应用串起来,形成一个完整的知识闭环。对于有一定经验、想深入了解推荐系统基本原理的开发者,这也是一个绝佳的“麻雀虽小,五脏俱全”的实践案例。我们不会上来就搞复杂的深度学习模型,而是从最经典、最易理解的协同过滤算法开始,一步步构建一个能实际运行、给出推荐结果的Web应用。整个过程,你会清晰地看到数据如何流动,算法如何工作,以及结果如何呈现给用户。

2. 系统整体设计与技术选型考量

2.1 为什么是Django + Python?

在动手之前,我们先聊聊为什么选这个技术栈,这比直接写代码更重要。很多新手会纠结于技术选型,我的经验是: 没有最好的技术,只有最适合场景和团队的技术。

首先看 Django 。它是一个“大而全”的高级Web框架,遵循“约定优于配置”的原则。这意味着它为你预设好了一套最佳实践,比如MVT(Model-View-Template)架构、自带ORM(对象关系映射)、强大的Admin后台、用户认证系统等。对于电影推荐系统这种需要管理用户、电影、评分等多种数据关系的项目,Django的ORM能让你用Python类来定义数据表,完全不用写繁琐的SQL语句,开发效率极高。它的Admin后台更是“神器”,项目初期,你几乎不用自己写任何管理页面,就能对数据库进行增删改查,非常适合快速原型验证。

再说 Python 。在推荐系统领域,Python几乎是唯一的选择。其核心优势在于庞大的数据科学生态。实现协同过滤,你需要计算用户或物品之间的相似度, numpy 提供了高效的数组运算;你需要处理数据表格, pandas 能让你像操作Excel一样轻松;你需要实现机器学习算法, scikit-learn 里集成了大量经典算法,甚至包括协同过滤的变种。用Python,你可以用最简洁的代码表达复杂的数学逻辑。

注意 :虽然Django很强大,但它也比较“重”。如果你的项目极端追求性能或需要微服务架构,可能会考虑Flask或FastAPI。但对于我们这个以学习和快速实现为核心目标的电影推荐系统,Django的综合优势是压倒性的。

2.2 系统架构与核心模块拆解

一个完整的电影推荐系统,远不止一个算法那么简单。我们需要把它拆解成几个松耦合的模块,这样代码结构清晰,也便于后续维护和扩展。我设计的核心架构分为四层:

  1. 数据层 :这是系统的基石。负责存储所有数据,包括电影信息(标题、类型、年份等)、用户信息、以及最重要的用户-电影评分数据。我们将使用Django的Model来定义这些数据结构,并利用ORM与数据库(如SQLite或PostgreSQL)交互。
  2. 算法层 :这是系统的大脑。核心推荐逻辑在这里实现。我们会先实现基于用户的协同过滤和基于物品的协同过滤。这一层会从数据层读取评分矩阵,进行计算,并输出推荐结果(电影ID列表)。
  3. 业务逻辑层 :这是系统的中枢。它接收来自用户界面的请求(比如“给我推荐电影”),调用算法层获取结果,然后结合数据层获取电影的详细信息(如海报、简介),组装成最终呈现给用户的数据。在Django中,这部分逻辑通常写在View(视图)函数或类中。
  4. 表现层 :这是系统的脸面。负责将数据渲染成用户看到的网页。我们会使用Django的Template模板语言,结合HTML/CSS/JavaScript(可以引入Bootstrap等前端框架让页面更美观)来构建用户界面,包括电影列表页、详情页、评分页面和最重要的推荐结果展示页。

各层之间通过清晰的接口调用,数据层为算法层和业务层提供数据服务,算法层为业务层提供“智力”支持,业务层协调各方,最终通过表现层交付价值。这种分层设计确保了当你想更换推荐算法(比如从协同过滤换成基于内容的推荐)时,只需要修改算法层,其他层几乎不用动。

3. 数据模型设计与核心算法原理

3.1 数据库模型设计详解

好的开始是成功的一半,数据库设计就是这“一半”。我们的核心实体有三个: User (用户)、 Movie (电影)、 Rating (评分)。Django已经内置了功能强大的 User 模型,我们通常直接使用或扩展它,这里为了简化,我们先使用内置用户模型。

首先定义 Movie 模型。一部电影有哪些属性是推荐系统关心的?标题、类型(流派)、上映年份、简介、海报链接是基础。更重要的是,为了后续可能实现基于内容的推荐,我们需要把电影类型这种多值字段处理好。

# models.py
from django.db import models

class Movie(models.Model):
    # 基础信息
    title = models.CharField(max_length=200, verbose_name='电影标题')
    year = models.IntegerField(verbose_name='上映年份', null=True, blank=True)
    description = models.TextField(verbose_name='简介', blank=True)
    poster_url = models.URLField(verbose_name='海报链接', max_length=500, blank=True)
    
    # 关键:电影类型。一部电影可能属于多个类型,如“动作,科幻”。
    # 这里我们存储为逗号分隔的字符串,如 "Action,Sci-Fi,Adventure"
    # 更规范的做法是建立独立的Genre模型和多对多关系,但为简化起步,先这样处理。
    genres = models.CharField(max_length=100, verbose_name='类型', blank=True)
    
    # 冗余字段,用于简化基于内容的相似度计算(可选)
    # 可以将genres字段向量化后存储,避免每次实时计算
    # genre_vector = models.BinaryField(null=True, blank=True)
    
    def __str__(self):
        return f"{self.title} ({self.year})"

接下来是核心的 Rating 模型。它连接了 User 和 Movie ,记录了用户对电影的评分(比如1-5分)。这个模型是协同过滤算法的“燃料”。

# models.py
from django.contrib.auth.models import User

class Rating(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='用户')
    movie = models.ForeignKey(Movie, on_delete=models.CASCADE, verbose_name='电影')
    # 评分,通常为1-5的整数或0.5的倍数(如3.5)
    score = models.FloatField(verbose_name='评分')
    created_at = models.DateTimeField(auto_now_add=True, verbose_name='评分时间')
    
    class Meta:
        # 确保一个用户对同一部电影只能评分一次
        unique_together = ('user', 'movie')
        verbose_name = '用户评分'
    
    def __str__(self):
        return f"{self.user.username} 给 《{self.movie.title}》 评分:{self.score}"

实操心得 :在项目初期,使用 CharField 存储逗号分隔的类型字符串是快速验证想法的好办法。但当系统复杂后,强烈建议拆分成独立的 Genre 模型并使用 ManyToManyField 。因为查询“所有科幻电影”时,用字符串 LIKE 查询效率低下且有误判风险(比如“科幻喜剧”会被“科幻”匹配到)。先跑通流程,再优化结构,是敏捷开发的关键。

3.2 协同过滤算法原理解析与选择

推荐算法的核心是“物以类聚,人以群分”。协同过滤正是基于这一思想,它分为两大类:

基于用户的协同过滤 :假设“兴趣相似的用户喜欢的东西也相似”。算法步骤是:

  1. 找到与目标用户A评分行为最相似的K个用户(邻居)。
  2. 将这些邻居喜欢(高评分)、但用户A尚未看过的电影,根据邻居的相似度加权,推荐给A。

基于物品的协同过滤 :假设“喜欢物品A的用户也喜欢物品B”。这是目前工业界更主流的方法,因为物品的相似度相对用户的兴趣更稳定。算法步骤是:

  1. 计算电影之间的相似度(基于所有用户对它们的评分)。
  2. 对于目标用户A评分高的电影,找出与这些电影最相似的、且用户A未看过的电影,加权后推荐。

我们如何计算相似度? 最常用的是 余弦相似度 和 皮尔逊相关系数 。想象一个多维空间,每个用户或电影都是一个向量(向量坐标是他们对各个电影或来自各个用户的评分)。余弦相似度计算的是两个向量夹角的余弦值,忽略向量的绝对长度(即评分尺度),只关心评分模式是否一致。皮尔逊相关系数更进一步,它去除了用户评分偏置(比如有的用户习惯性打高分,有的则苛刻),衡量的是评分变化的趋势是否一致。

对于我们的电影推荐系统,我建议 优先实现基于物品的协同过滤 。原因有三:第一,电影数量通常相对稳定,相似度矩阵可以提前计算并缓存,响应速度快;第二,它更易于解释(“因为你喜欢《星际穿越》,所以我们推荐《盗梦空间》”);第三,对用户冷启动问题(新用户没有评分)稍微友好一些,我们可以用热门电影或基于电影属性的推荐作为补充。

4. 核心算法实现与Django集成

4.1 基于物品的协同过滤代码实现

理论说完了,我们上代码。首先,我们需要一个服务类或工具函数来封装推荐逻辑。我在项目里通常会创建一个 recommender 的Python包,或者在 utils 目录下建立 recommendation.py 文件。

第一步,构建用户-物品评分矩阵。这是一个二维矩阵,行是用户,列是电影,值是评分。由于用户和电影数量很大,矩阵会非常稀疏(大部分是空值,因为用户只看过极少部分电影)。我们使用 pandas 的 DataFrame 和 scipy 的稀疏矩阵来处理,以节省内存。

# utils/recommendation.py
import pandas as pd
import numpy as np
from scipy.sparse import csr_matrix
from sklearn.metrics.pairwise import cosine_similarity
from django.db.models import Count
from .models import Rating, Movie

class ItemCFRecommender:
    def __init__(self):
        self.similarity_matrix = None # 物品相似度矩阵
        self.movie_id_to_index = {} # 电影ID到矩阵列索引的映射
        self.index_to_movie_id = {} # 矩阵列索引到电影ID的映射
        
    def fit(self, ratings_dataframe):
        """
        训练模型,计算电影相似度矩阵。
        :param ratings_dataframe: 包含'user_id', 'movie_id', 'score'三列的DataFrame
        """
        # 创建用户-电影评分矩阵(稀疏)
        user_item_matrix = ratings_dataframe.pivot_table(
            index='user_id', columns='movie_id', values='score'
        ).fillna(0) # 将NaN填充为0,表示未评分
        
        # 转换为稀疏矩阵格式,节省内存
        sparse_matrix = csr_matrix(user_item_matrix.values)
        
        # 计算物品(电影)之间的余弦相似度
        # 这里计算的是物品向量(列向量)之间的相似度
        # 转置矩阵,使每行代表一个物品(电影)
        item_similarity = cosine_similarity(sparse_matrix.T)
        
        # 存储相似度矩阵和索引映射
        self.similarity_matrix = item_similarity
        self.movie_id_to_index = {id: idx for idx, id in enumerate(user_item_matrix.columns)}
        self.index_to_movie_id = {idx: id for idx, id in enumerate(user_item_matrix.columns)}
        
    def recommend_for_user(self, user_id, ratings_dataframe, top_n=10):
        """
        为指定用户生成推荐。
        :param user_id: 目标用户ID
        :param ratings_dataframe: 评分数据
        :param top_n: 推荐数量
        :return: 推荐的电影ID列表
        """
        if self.similarity_matrix is None:
            raise ValueError("请先调用 fit() 方法训练模型。")
            
        # 获取该用户的历史评分记录
        user_ratings = ratings_dataframe[ratings_dataframe['user_id'] == user_id]
        if user_ratings.empty:
            # 用户无历史评分,退回热门推荐或随机推荐
            return self._get_fallback_recommendations(top_n)
        
        # 初始化一个字典来存储电影的总推荐权重
        recommendation_scores = {}
        
        # 遍历用户评分过的每一部电影
        for _, row in user_ratings.iterrows():
            movie_id = row['movie_id']
            rating_score = row['score']
            
            # 获取该电影在相似度矩阵中的索引
            if movie_id not in self.movie_id_to_index:
                continue
            movie_idx = self.movie_id_to_index[movie_id]
            
            # 获取与该电影最相似的其他电影(相似度向量)
            similarity_scores = list(enumerate(self.similarity_matrix[movie_idx]))
            # 按相似度降序排序
            similarity_scores = sorted(similarity_scores, key=lambda x: x[1], reverse=True)
            
            # 遍历相似电影,累加推荐权重
            for other_movie_idx, similarity in similarity_scores:
                other_movie_id = self.index_to_movie_id[other_movie_idx]
                
                # 跳过用户已经看过的电影
                if other_movie_id in user_ratings['movie_id'].values:
                    continue
                    
                # 推荐权重 = 用户对该电影的评分 * 两部电影的相似度
                # 用户评分越高,相似度越高,则推荐权重越大
                if other_movie_id not in recommendation_scores:
                    recommendation_scores[other_movie_id] = 0
                recommendation_scores[other_movie_id] += rating_score * similarity
        
        # 按推荐权重降序排序,取前top_n个
        sorted_recommendations = sorted(recommendation_scores.items(), key=lambda x: x[1], reverse=True)
        recommended_movie_ids = [movie_id for movie_id, _ in sorted_recommendations[:top_n]]
        
        return recommended_movie_ids
    
    def _get_fallback_recommendations(self, top_n):
        """冷启动处理:返回评分次数最多的热门电影"""
        from django.db.models import Count
        popular_movies = Movie.objects.annotate(rating_count=Count('rating')).order_by('-rating_count')[:top_n]
        return [movie.id for movie in popular_movies]

这段代码的核心是 fit 和 recommend_for_user 两个方法。 fit 方法在系统启动或定期任务中执行,计算好所有电影两两之间的相似度并存储起来,这是一个计算密集型但可以离线的过程。 recommend_for_user 方法则在用户请求推荐时被调用,它利用预计算好的相似度矩阵和用户的历史评分,快速计算出推荐列表。

4.2 在Django视图中集成推荐服务

算法准备好了,现在需要把它接入Django的Web流程。我们创建一个视图函数来处理推荐请求。

首先,我们需要一个方式将数据库中的评分数据加载到 pandas DataFrame 中,并初始化推荐器。为了避免每次请求都重新计算相似度矩阵(这非常耗时),我们需要在服务启动时计算一次,并将其缓存起来。Django的缓存框架非常适合做这个。

# views.py
from django.shortcuts import render, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.core.cache import cache
from django.http import JsonResponse
import pandas as pd
from .models import Rating, Movie
from .utils.recommendation import ItemCFRecommender

@login_required
def get_recommendations(request):
    """为用户获取电影推荐列表"""
    user = request.user
    
    # 尝试从缓存获取推荐器实例
    recommender_key = 'item_cf_recommender'
    recommender = cache.get(recommender_key)
    
    if recommender is None:
        # 缓存未命中,需要重新训练并缓存推荐器
        print("训练推荐模型...")
        # 从数据库获取所有评分数据
        ratings_queryset = Rating.objects.select_related('movie', 'user').all()
        ratings_list = list(ratings_queryset.values('user_id', 'movie_id', 'score'))
        
        if not ratings_list:
            # 如果没有评分数据,返回空或热门电影
            popular_movies = Movie.objects.annotate(rating_count=Count('rating')).order_by('-rating_count')[:10]
            return render(request, 'recommendations.html', {'movies': popular_movies})
        
        # 转换为DataFrame
        ratings_df = pd.DataFrame(ratings_list)
        
        # 初始化并训练推荐器
        recommender = ItemCFRecommender()
        recommender.fit(ratings_df)
        
        # 将训练好的推荐器存入缓存,设置过期时间(例如6小时)
        # 注意:复杂对象缓存可能需要pickle序列化,确保ItemCFRecommender类可序列化
        cache.set(recommender_key, recommender, timeout=60*60*6)
        print("模型训练完成并已缓存。")
    
    # 获取当前用户的评分数据(用于推荐计算)
    user_ratings = Rating.objects.filter(user=user).values('movie_id', 'score')
    user_ratings_df = pd.DataFrame(list(user_ratings))
    # 需要所有评分数据来构建用户向量,这里简单复用全量数据
    # 更优做法是传递全量ratings_df,但注意数据一致性
    all_ratings = Rating.objects.all().values('user_id', 'movie_id', 'score')
    all_ratings_df = pd.DataFrame(list(all_ratings))
    
    # 获取推荐电影ID列表
    recommended_movie_ids = recommender.recommend_for_user(user.id, all_ratings_df, top_n=10)
    
    # 根据ID列表查询电影详细信息
    recommended_movies = Movie.objects.filter(id__in=recommended_movie_ids)
    # 注意:上面filter返回的顺序可能与推荐列表顺序不一致,需要排序
    # 创建一个ID到电影对象的映射,然后按推荐顺序排列
    movie_dict = {movie.id: movie for movie in recommended_movies}
    ordered_movies = [movie_dict[mid] for mid in recommended_movie_ids if mid in movie_dict]
    
    # 渲染模板或返回JSON数据
    if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
        # AJAX请求,返回JSON
        data = [{'id': m.id, 'title': m.title, 'year': m.year} for m in ordered_movies]
        return JsonResponse({'recommendations': data})
    else:
        # 普通请求,渲染HTML页面
        return render(request, 'movies/recommendations.html', {'recommended_movies': ordered_movies})

这个视图做了几件关键事情:1)使用缓存避免重复训练模型;2)从数据库获取数据并转换为算法需要的格式;3)调用推荐器获得结果;4)将结果返回给前端。 @login_required 装饰器确保了只有登录用户才能获得个性化推荐。

重要提示 :在实际生产环境中,将整个推荐器对象缓存可能不是最佳选择,特别是当数据量巨大时,序列化和反序列化开销大,且模型更新不灵活。更常见的做法是只将计算好的 物品相似度矩阵 ( similarity_matrix )和 索引映射 ( movie_id_to_index )缓存起来,或者使用专门的模型存储服务。这里为了演示Django缓存的使用和流程的完整性,采用了缓存整个对象的方式。对于学习项目,这完全可行。

5. 前端展示与用户交互实现

5.1 构建电影展示与评分页面

推荐结果最终需要呈现给用户。我们需要一个简洁明了的页面来展示电影列表,并允许用户进行评分,因为用户的评分反馈是驱动推荐系统迭代优化的燃料。

首先,创建电影列表页,展示所有电影或搜索结果的电影。我们使用Django模板语言来动态生成内容。

<!-- templates/movies/movie_list.html -->
{% extends 'base.html' %}
{% block content %}
<h2>电影库</h2>
<div class="row">
    {% for movie in movies %}
    <div class="col-md-3 mb-4">
        <div class="card h-100">
            {% if movie.poster_url %}
            <img src="{{ movie.poster_url }}" class="card-img-top" alt="{{ movie.title }}" style="height: 300px; object-fit: cover;">
            {% else %}
            <div class="card-img-top bg-secondary d-flex align-items-center justify-content-center" style="height: 300px;">
                <span class="text-white">暂无海报</span>
            </div>
            {% endif %}
            <div class="card-body">
                <h5 class="card-title">{{ movie.title }} ({{ movie.year }})</h5>
                <p class="card-text text-muted genres">
                    {% for genre in movie.genres.split|slice:":3" %}
                    <span class="badge bg-info me-1">{{ genre }}</span>
                    {% endfor %}
                </p>
                <p class="card-text small">{{ movie.description|truncatechars:100 }}</p>
            </div>
            <div class="card-footer">
                <!-- 显示用户已有评分 -->
                {% with user_rating=movie.user_rating %}
                {% if user_rating %}
                <p class="mb-1">我的评分: 
                    <span class="star-rating text-warning">
                        {% for i in "12345" %}
                            {% if forloop.counter <= user_rating %}★{% else %}☆{% endif %}
                        {% endfor %}
                    </span>
                    ({{ user_rating }})
                </p>
                {% endif %}
                {% endwith %}
                <!-- 评分表单 -->
                <form method="post" action="{% url 'rate_movie' movie.id %}" class="d-inline">
                    {% csrf_token %}
                    <div class="btn-group" role="group">
                        {% for i in "12345" %}
                        <button type="submit" name="score" value="{{ forloop.counter }}" class="btn btn-outline-primary btn-sm">
                            {{ forloop.counter }}★
                        </button>
                        {% endfor %}
                    </div>
                </form>
                <a href="{% url 'movie_detail' movie.id %}" class="btn btn-link btn-sm float-end">详情</a>
            </div>
        </div>
    </div>
    {% empty %}
    <div class="col-12">
        <p class="text-center">暂无电影数据。</p>
    </div>
    {% endfor %}
</div>
{% endblock %}

这个模板使用了Bootstrap 5的卡片布局,使电影展示更美观。关键点在于评分部分:我们通过一个简单的表单,将评分值(1-5)提交到后端。这里为了用户体验,直接用了按钮提交,实际项目中可以考虑使用AJAX实现无刷新评分。

对应的视图需要处理评分提交,并更新或创建 Rating 记录。

# views.py
from django.shortcuts import redirect, get_object_or_404
from django.contrib import messages
from django.contrib.auth.decorators import login_required

@login_required
def rate_movie(request, movie_id):
    """处理用户评分"""
    if request.method == 'POST':
        movie = get_object_or_404(Movie, id=movie_id)
        score = request.POST.get('score')
        try:
            score = float(score)
            if 1 <= score <= 5:
                # 使用update_or_create避免重复评分
                rating, created = Rating.objects.update_or_create(
                    user=request.user,
                    movie=movie,
                    defaults={'score': score}
                )
                if created:
                    messages.success(request, f'已为《{movie.title}》评分 {score} 星。')
                else:
                    messages.info(request, f'已更新《{movie.title}》的评分为 {score} 星。')
                # 清除推荐缓存,因为用户行为改变了
                cache.delete('item_cf_recommender')
            else:
                messages.error(request, '评分必须在1到5之间。')
        except ValueError:
            messages.error(request, '无效的评分。')
    # 重定向回电影列表页或来源页
    return redirect(request.META.get('HTTP_REFERER', 'movie_list'))

5.2 推荐结果页与个性化展示

推荐结果页是系统的价值出口。它的设计应该清晰、有说服力,告诉用户“为什么推荐这些电影给你”。

<!-- templates/movies/recommendations.html -->
{% extends 'base.html' %}
{% block content %}
<h2>为你推荐</h2>
<p class="text-muted">基于你的观影历史和品味,我们发现了这些你可能感兴趣的电影。</p>

{% if recommended_movies %}
<div class="row">
    {% for movie in recommended_movies %}
    <div class="col-lg-6 mb-4">
        <div class="card">
            <div class="row g-0">
                <div class="col-md-4">
                    {% if movie.poster_url %}
                    <img src="{{ movie.poster_url }}" class="img-fluid rounded-start" alt="{{ movie.title }}" style="height: 200px; width: 100%; object-fit: cover;">
                    {% endif %}
                </div>
                <div class="col-md-8">
                    <div class="card-body">
                        <h5 class="card-title">{{ movie.title }} ({{ movie.year }})</h5>
                        <p class="card-text"><small class="text-muted">{{ movie.genres }}</small></p>
                        <p class="card-text">{{ movie.description|truncatechars:150 }}</p>
                        <div class="d-flex justify-content-between align-items-center">
                            <div>
                                <!-- 可以在这里加入推荐理由,例如“与你喜欢的《XXX》相似” -->
                                <!-- 这需要后端传递更多信息,暂时留空 -->
                                <span class="badge bg-success">推荐</span>
                            </div>
                            <div>
                                <a href="{% url 'movie_detail' movie.id %}" class="btn btn-primary btn-sm">查看详情</a>
                                <!-- 快速评分按钮组 -->
                                <div class="btn-group ms-2" role="group">
                                    {% for i in "12345"|slice:":3" %}
                                    <form method="post" action="{% url 'rate_movie' movie.id %}" class="d-inline">
                                        {% csrf_token %}
                                        <button type="submit" name="score" value="{{ forloop.counter }}" class="btn btn-outline-secondary btn-sm">
                                            {{ forloop.counter }}★
                                        </button>
                                    </form>
                                    {% endfor %}
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </div>
    {% endfor %}
</div>
{% else %}
<div class="alert alert-info">
    <h4 class="alert-heading">暂无个性化推荐</h4>
    <p>这可能是因为你还没有对任何电影进行评分,或者系统正在计算中。你可以先去 <a href="{% url 'movie_list' %}">浏览电影</a> 并评分,帮助我们更好地了解你的喜好。</p>
</div>
{% endif %}

<!-- 可以添加一个“换一批”或“调整推荐”的按钮,通过AJAX获取新的推荐 -->
<div class="text-center mt-4">
    <button id="refresh-rec" class="btn btn-outline-secondary">换一批推荐</button>
</div>

<script>
// 简单的AJAX示例:点击换一批
document.getElementById('refresh-rec').addEventListener('click', function() {
    fetch("{% url 'get_recommendations' %}", {
        headers: {
            'X-Requested-With': 'XMLHttpRequest'
        }
    })
    .then(response => response.json())
    .then(data => {
        console.log('收到新推荐:', data);
        // 这里需要实现前端更新列表的逻辑,可以使用前端框架或手动更新DOM
        alert('已获取新推荐,前端列表更新逻辑需自行实现。');
    });
});
</script>
{% endblock %}

这个页面不仅展示了推荐结果,还提供了快速的评分入口,形成了一个“评分 -> 更新模型 -> 获得新推荐”的闭环。页面底部的“换一批推荐”按钮,通过AJAX技术,可以在不刷新页面的情况下请求新的推荐列表,提升了用户体验。

6. 系统优化、部署与常见问题

6.1 性能优化与可扩展性考虑

当你的电影和用户数据从几百增长到几千、几万时,最初的简单实现可能会遇到性能瓶颈。以下是几个关键的优化方向:

1. 相似度矩阵的计算与存储优化: 计算所有电影两两之间的相似度,时间复杂度是O(n²),当电影数(n)很大时,计算会非常慢。解决方案:

  • 离线计算与定期更新 :使用Celery等异步任务队列,在服务器空闲时(如凌晨)计算相似度矩阵,并存入数据库或高速缓存(如Redis)。Django视图直接读取缓存结果。
  • 稀疏矩阵与近似计算 :使用 scipy.sparse 库存储稀疏矩阵。对于大规模数据,可以考虑使用近似最近邻搜索算法(如Annoy, Faiss)来快速查找相似物品,而不是计算全量相似度。
  • 分块计算 :如果数据实在太大,可以将电影按类型或其他维度分块,只在块内计算相似度。

2. 数据库查询优化:

  • 使用 select_related 和 prefetch_related :在Django ORM查询电影及其关联的评分时,务必使用这两个方法来避免N+1查询问题。例如: Movie.objects.prefetch_related('rating_set').all() 。
  • 建立索引 :为 Rating 表的 user_id 和 movie_id 字段建立数据库索引,能极大提升根据用户或电影查询评分记录的速度。
  • 数据聚合 :对于热门电影、平均分等频繁访问的统计信息,可以定期计算并存储在单独的模型字段中,用空间换时间。

3. 推荐实时性: 我们的基础实现是“离线训练,在线推荐”。用户新产生的评分需要等到下次模型训练时才能影响推荐结果。为了提升实时性,可以引入“在线学习”或“混合策略”:

  • 混合推荐 :将基于物品的协同过滤(离线)与基于内容的推荐(实时)结合。当用户新评分一部电影后,立即基于这部电影的内容(类型、导演等)推荐相似电影作为补充。
  • 增量更新 :当用户新增一条评分时,不重新计算整个相似度矩阵,而是只更新与该电影相关的相似度行。这需要更复杂的算法实现。

4. 缓存策略升级:

  • 分级缓存 :不仅缓存模型,还可以缓存每个用户的推荐结果。为每个用户生成一个推荐列表并缓存(设置较短过期时间,如10分钟)。这样同一用户短时间内重复访问推荐页,响应速度极快。
  • 使用更快的缓存后端 :对于生产环境,使用Redis或Memcached替代Django的本地内存缓存。

6.2 常见问题排查与调试技巧

在开发过程中,你肯定会遇到各种问题。这里记录几个我踩过的坑和解决方法:

问题1:推荐结果总是热门电影,没有个性化。

  • 可能原因 :评分数据太少,或者用户之间、电影之间的评分重叠度太低,导致算法无法计算出有效的相似度。在数据稀疏的情况下,基于物品的协同过滤会退化成热门推荐。
  • 排查与解决 :
    1. 检查数据 :打印出评分矩阵的稀疏度(非零元素比例)。如果低于1%,个性化效果会很差。
    2. 数据填充 :尝试使用用户平均分或电影平均分来填充矩阵中的零值,但这会引入偏差,需谨慎。
    3. 算法调整 :尝试使用 基于模型的协同过滤 ,如矩阵分解(SVD),这类方法对稀疏数据的处理能力更强。可以使用 surprise 库快速尝试。
    4. 引入冷启动策略 :对于新用户或评分少的用户,直接展示热门电影、最新电影或随机电影是可接受的,并强烈引导用户去评分。

问题2:模型训练( fit 方法)速度太慢,请求超时。

  • 可能原因 :直接在Web请求中同步执行 fit 方法。计算相似度矩阵是CPU密集型任务,会阻塞整个请求。
  • 解决 :
    1. 绝对禁止在视图请求中同步训练 !必须改为异步任务。
    2. 使用 Celery + Redis 组合。将 fit 任务放入Celery队列,由后台Worker进程执行。视图函数只触发任务,并立即返回“模型正在训练中”的提示。训练完成后,将结果写入缓存或数据库。
    3. 在 settings.py 中配置Celery。

问题3:新电影或新用户(冷启动)无法获得推荐。

  • 这是推荐系统的经典难题 。我们的 _get_fallback_recommendations 方法只是简单退回热门电影。
  • 更优的混合方案 :
    1. 基于内容的推荐 :对于新电影,利用其 genres , description 等属性,计算与其他电影的文本相似度(如TF-IDF + 余弦相似度),作为补充推荐源。
    2. 探索与利用 :在推荐列表中,混入少量随机的新电影或冷门电影,收集用户反馈,解决冷启动的同时也能探索用户潜在兴趣。
    3. 注册信息利用 :新用户注册时,可以让其选择感兴趣的电影类型,作为初始推荐依据。

问题4:Django缓存存储复杂对象报错( PickleError )。

  • 可能原因 : ItemCFRecommender 类或其属性(如 similarity_matrix 是numpy数组)不能被默认的pickle序列化。
  • 解决 :
    1. 实现自定义的序列化方法。为 ItemCFRecommender 类添加 __getstate__ 和 __setstate__ 方法,将numpy数组转换为Python列表再存储,读取时再转回numpy数组。
    2. 更推荐的做法 :不缓存整个对象,而是只缓存核心数据。将 similarity_matrix (转换为列表或二进制)、 movie_id_to_index 、 index_to_movie_id 这三个核心数据分别用简单的数据结构(如字典、列表)缓存。在视图里取出这些数据,再重新组装成推荐器。这样更可控,也节省缓存空间。
# 在ItemCFRecommender类中添加序列化支持
def __getstate__(self):
    # 将numpy数组转换为列表,字典等可序列化对象
    state = self.__dict__.copy()
    if isinstance(self.similarity_matrix, np.ndarray):
        state['similarity_matrix'] = self.similarity_matrix.tolist()
    # 确保其他属性都是可序列化的
    return state

def __setstate__(self, state):
    # 从状态中恢复,将列表转回numpy数组
    if 'similarity_matrix' in state and isinstance(state['similarity_matrix'], list):
        state['similarity_matrix'] = np.array(state['similarity_matrix'])
    self.__dict__.update(state)

问题5:前端评分提交后页面刷新,体验不好。

  • 解决 :使用AJAX实现异步评分。给评分按钮绑定点击事件,通过JavaScript发送POST请求到后端,后端处理完成后返回JSON状态,前端根据状态更新页面上的评分显示(如将按钮高亮),而无需刷新整个页面。这能极大提升用户体验,鼓励用户进行更多评分互动。

本文还有配套的精品资源,点击获取 menu-r.4af5f7ec.gif

在ssh中加入jbpm工作流所需要的包 在ssh中加入jbpm工作流所需要的包 在ssh中加入jbpm工作流所需要的包 在ssh中加入jbpm工作流所需要的包 在ssh中加入jbpm工作流所需要的包 立即下载

相关推荐

chrome-win64-159.0.8145.0(Canary).zip

内容概要:Chrome for Testing 官方 chrome 159.0.8145.0 win64 平台(金丝雀版通道),原版未修改,附来源说明。 适合人群:Windows 64 位 上的自动化测试工程师、爬虫开发者、CI 环境搭建者。 使用场景及目标:①Chrome for Testing 官方浏览器本体,供自动化测试使用;②与同版本 chromedriver 配套;③CI/容器环境的浏览器运行时。 其他说明:Chrome for Testing 为 Google 官方发布、允许自由分发的文件;本资源为第三方整理的下载便利服务。

给sshpermissions加入工作流

第一章 引言 1.1 编写目的 在sshpermissions中加入工作流部分,主要整合的是jbpm4.4。并且将流程设计器和业务做了初步的整合。同时也修改了前期的一些bug。 1.2 关于jbpm JBPM,全称是Java Business Process Management(业务流程管理),它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流...

131

chrome-headless-shell-win64-157.0.8103.38(Stable).zip

Chrome for Testing 官方指定版本的 Chrome 浏览器、ChromeDriver 与 Headless Shell 压缩包,适用于 Selenium、Playwright 等自动化测试环境搭建,覆盖 Windows、macOS、Linux 多平台,解压即可使用,无需额外安装或配置。

开源权限系统sshpermissions

开源权限系统sshpermissions 第一章 引言 1.1 编写目的 使用easyui+ssh2+shiro的权限管理系统,粒度可细化到按钮及菜单级别。目前是第一个稳定版本,可实现基本的权限控制功能,并且可以使用shiro的标签对细粒度的权限进行管理。 Jar包除了几个核心包之外全部使用maven管理。 1.2 是否开源 完全开源免费。 地址是: https://cod

quasiceo 2198

chrome-win32-159.0.8150.0(Canary).zip

内容概要:Chrome for Testing 官方 chrome 159.0.8150.0 win32 平台(金丝雀版通道),原版未修改,附来源说明。 适合人群:Windows 32 位 上的自动化测试工程师、爬虫开发者、CI 环境搭建者。 使用场景及目标:①Chrome for Testing 官方浏览器本体,供自动化测试使用;②与同版本 chromedriver 配套;③CI/容器环境的浏览器运行时。 其他说明:Chrome for Testing 为 Google 官方发布、允许自由分发的文件;本资源为第三方整理的下载便利服务。

chromedriver-win32-160.0.8164.0(Canary).zip

chromedriver-win32-160.0.8164.0(Canary).zip

SSH-------------- 角色到activiti的组\把用户添加到activiti的用户

角色到activiti的组 1、IRoleServiceImpl public void save(Role role, String fundids) { iRoleDao.save(role); Group group = new GroupEntity(); group.setId(role.getName()); group.setName(role.getName()); identityService.saveGroup(group); .

qq_32659773的博客 227

化工MES-石化盈科信息技术有限责任公司.pptx

化工MES-石化盈科信息技术有限责任公司.pptx

SSH与工作流Activiti的集成开发

Activiti 数据库表结构说明: 数据库表结构说明: ·ACT_GE_PROPERTY:属性数据表。存储整个流程引擎级别的数据。 1.NAME_:属性名称 2.VALUE_:属性值 3.REV_INT:版本号? ·ACT_GE_BYTEARRAY:用来保存部署文件的大文本数据的。 1.ID_:资源文件编号,自增长 2.REV_INT:版本号? 3.NAME_:资源文件名称...

20386053 326

健康管理服务运营方案.pptx

健康管理服务运营方案.pptx

TVJ1120资源及合并指令

内容概要:本文提供了TVJ1120.apk拆分文件的下载链接及合并方法,包含两个分卷文件(part1和part2)的CSDN下载地址,并给出在Windows系统下使用copy命令将两个分卷合并为完整APK文件的具体指令。同时提供使用certutil工具对合并后的TVJ1120.apk进行SHA256哈希值校验的命令,以确保文件完整性与安全性。; 适合人群:具备基本计算机操作能力,熟悉命令行工具使用的开发者或技术人员;需要下载并验证安卓应用文件完整性的用户。; 使用场景及目标:①用于从分卷压缩或拆分的APK文件中恢复完整的安装包;②通过哈希校验确保下载的APK文件未被篡改或损坏,保障应用安全性和可用性;③适用于软件分发、移动应用测试、逆向分析等技术场景。; 阅读建议:在操作前确认已下载全部分卷文件,并在相同目录下执行合并命令;建议严格比对生成的SHA256值与官方提供的校验值,防止运行不安全的应用程序。

关于权限管理Shiro的开源项目sshpermissions的maven环境搭建

此处声明 ,关于sshpermissions 开源项目本人没有参与,在此把此开源项目的基本环境搭建和大家共享一下,如有侵权,请跟帖说明。感谢sshpermissions的作者对开源项目的无私贡献。 在此简单说明一下sshpermissions:此项目主要使用shiro作为权限管理框架,同时使用了jbpm工作流等框架,对于想学习这两方面知识的同学应该有帮助。 此处附上sshpermissions...

iteye_7818的博客 184

UniApp X 网络请求避坑指南:从 JS 到 UTS 的 JSON 数据处理全解析

摘要:UniAppX开发中处理JSON数据时,UTS强类型特性要求开发者改变JS习惯。本文对比两种主流方案:1)UTSJSONObject通过keypath访问数据,兼容JS但缺乏类型提示;2)type+泛型方案,通过定义数据类型实现强类型校验和智能提示,推荐用于固定数据结构。文章详细演示了两种方式的具体实现、转换方法及实战案例,并提供了类型定义技巧和注意事项,帮助开发者编写更稳定高效的跨平台应用。

归梦工作室 2796

VSCode远程开发踩坑记:手把手解决Windows下SSH密钥‘权限太开放’报错

本文详细解析了Windows下使用VSCode进行远程开发时遇到的SSH密钥‘权限太开放’报错问题,提供了图形界面和PowerShell脚本两种解决方案,并深入探讨了NTFS与Linux权限模型的差异,帮助开发者彻底解决这一常见但棘手的权限问题。

weixin_30268071的博客 439

HC-05蓝牙模块AT指令配置避坑全记录:从配对失败到稳定主从通信

本文详细记录了HC-05蓝牙模块AT指令配置的全过程,从基础认知到主从通信的稳定实现。涵盖了进入AT模式的方法、关键AT指令详解、主从配对流程及常见故障排除,帮助开发者快速掌握蓝牙串口模块的配置技巧,避免常见配对失败问题。

weixin_42632434的博客 416

数据讲述中国故事!和鲸助力中国综合社会调查(CGSS)数据分析与可视化大赛圆满收官

用数据研究中国问题、总结中国道路、讲述中国故事。和鲸作为协办单位全程支持本次大赛,为中国人民大学中国调查与数据中心实施全套赛事系统,同时提供完备而周全的赛事运营服务。

ModelWhale的博客 1413

半天打造小型万能OA办公系统, 靠的就是万能表单提交 + 轻量级工作流审批组件...

   有时候我们会遇到这样的需求,公司不大,但是信息化程度也蛮高,公司的员工素质也很高,管理也很规范,甚至还有外地分公司,直接上一个OA系统吧,往往也无法符合公司的灵活管理需求, 往往受制于商品化OA的功能限制,商业限制.    直接定制一个OA系统也不大愿意承受几十万的开发费用,同时也不知道都提什么需求比较好,也不想去惹麻烦, 也没精力去整理需求.     那我们可以花一点儿时间了解...

weixin_34007879的博客 578

别再重启了!Win11开机卡死/间歇性卡顿的终极排查与修复指南(附免费工具)

本文提供Win11开机卡死和间歇性卡顿的终极排查与修复指南,涵盖从后台进程清理到驱动优化、系统组件修复及硬件监控的全方位解决方案。通过专业工具和详细步骤,帮助用户彻底解决Win11卡顿问题,无需重启或重装系统。

weixin_31102231的博客 773

GitHub Actions工作流语法

一个工作流示例. 欢迎来访我的个人博客Torch-Fan name: Build and Deploy to ACK on: release: types: [created] # Environment variables available to all jobs and steps in this workflow. env: REGION_ID: cn-hangzhou REGISTRY: registry.cn-hangzhou.aliyuncs.com NAMES.

fanqiliang630的博客 2422

华为od统一考试B卷【宜居星球改造计划】Java&Go 实现

XXX年,人类通过对火星的大气进行宜居改造分析,使得火星已在理论上具备人类宜居的条件,由于技术原因,无法一次性将火星大气全部改造,只能通过局部处理形式,假设将火星待改造的区域为row * column的网格每个网格有3个值,宜居区、可改造区、死亡区,使用YES、NO、NA代替,YES表示该网格已经完成大气改造,NO表示该网格未进行改造,后期可进行改造,NA表示死亡区,不作为判断是否改造完成的宜居,无法穿过 初始化下,该区域可能存在多个宜居区,并且每个宜居区能同时在每个太阳日单位向上下左右四个方向的相邻格子进

MISAYAONE的博客 1万+

潜望式长焦模组全解析:结构构造、光路设计与工程实战挑战

随着移动影像能力的不断进化,潜望式长焦模组成为旗舰手机实现 5x 甚至 10x 光学变焦的关键配置。相比传统横向堆叠镜组,潜望式结构通过反射棱镜实现纵向空间上的光路折叠,有效解决了模组厚度与变焦行程的矛盾问题。然而,高倍变焦模组不仅面临复杂的光学路径设计,还涉及反射损耗控制、防抖马达配合、模组热应力管控与 ISP 畸变校正等一系列工程难点。本文将结合主流机型的实战经验,深入解析潜望式长焦模组的结构构造与调试路径,为影像系统工程师提供完整的实战参考。

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 3145
上一篇: 5×7点阵字体素材:嵌入式开发与像素艺术中的开箱即用方案
下一篇: 基于SpringBoot+Thymeleaf+AI的智能社区服务管理系统毕业设计实战
weixin_34162228
博客等级 码龄11年 5374粉丝 1246原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址