Python Django 协同过滤电影推荐系统设计

3、项目说明

一、技术栈 本项目以 Python 为核心开发语言，后端基于 Django 框架搭配 django-rest-framework 搭建 MVC 架构，前端采用 bootstrap3、js、jquery 实现页面交互；数据库支持 SQLite3/MySQL，结合 requests 爬虫抓取豆瓣电影数据，核心运用协同过滤推荐算法实现电影智能推荐，整体构建起功能完整的电影推荐系统。

二、功能模块

• 数据采集：通过 Python 脚本配置请求头与目标 URL，设定多页链接范围启动爬虫，抓取豆瓣电影的名称、海报、导演、上映信息等 3000 条数据，抓取过程实时展示状态并同步记录数据，为系统提供充足的数据源支撑。
• 电影信息展示与管理：前台支持按标签筛选、热度/时间/评分排序展示电影列表，详情页呈现电影海报、剧情介绍等完整信息；后台可通过名称、导演等条件搜索电影，执行增删操作，统一管控电影基础数据。
• 用户交互（登录、注册、评分、收藏等）：提供用户注册、登录及信息修改功能，用户可对电影进行评分、收藏、评论，收藏页面可查看已收藏影片列表，满足用户个性化的观影交互需求。
• 电影推荐：基于用户和物品的协同过滤算法实现推荐，针对冷启动问题优化逻辑，以'相似度*评分'计算推荐值，根据用户点赞、收藏等行为推荐感兴趣的电影，推荐准确率约 75%，还支持'换一批'刷新推荐内容。
• 后台数据管理：提供快捷操作入口，可管理用户偏好、前台用户、电影标签、评分信息等内容，处理权限与用户组设置，展示最近操作记录，实现系统数据的全维度管控。

三、项目总结 本电影推荐系统采用分层模型设计，从数据采集到智能推荐形成完整闭环。前端侧重用户体验，实现电影多维度展示与交互操作；后端依托 Django 框架保障系统稳定性，结合协同过滤算法解决智能推荐核心需求，还针对冷启动问题优化推荐逻辑。系统不仅能抓取并管理海量豆瓣电影数据，还能基于用户行为精准推荐影片，推荐准确率达 75%，同时通过后台实现数据全生命周期管控，整体功能覆盖用户与管理员的核心需求，完成了预期的电影推荐与管理目标。

4、核心代码

# -*- coding: utf-8 -*-
import os
os.environ["DJANGO_SETTINGS_MODULE"] = "movie.settings"
import django
django.setup()
from movie.models import *
from math import sqrt, pow
import operator
from django.db.models import Subquery, Q, Count
# from django.shortcuts import render, render_to_response

class UserCf:
    # 获得初始化数据
    def __init__(self, all_user):
        self.all_user = all_user

    # 通过用户名获得列表，仅调试使用
    def getItems(self, username1, username2):
        return self.all_user[username1], self.all_user[username2]

    # 计算两个用户的皮尔逊相关系数
    def pearson(self, user1, user2):
        sum_xy = 0.0
        n = 0
        sum_x = 0.0
        sum_y = 0.0
        sumX2 = 0.0
        sumY2 = 0.0
        for movie1, score1 in user1.items():
            if movie1 in user2.keys():
                n += 1
                sum_xy += score1 * user2[movie1]
                sum_x += score1
                sum_y += user2[movie1]
                sumX2 += pow(score1, 2)
                sumY2 += pow(user2[movie1], 2)
        if n == 0:
            return 0
        molecule = sum_xy - (sum_x * sum_y) / n
        denominator = sqrt((sumX2 - pow(sum_x, 2) / n) * (sumY2 - pow(sum_y, 2) / n))
        if denominator == 0:
            return 0
        r = molecule / denominator
        return r

    # 计算与当前用户的距离，获得最临近的用户
    def nearest_user(self, current_user, n=1):
        distances = {}
        for user, rate_set in self.all_user.items():
            if user != current_user:
                distance = self.pearson(self.all_user[current_user], self.all_user[user])
                distances[user] = distance
        closest_distance = sorted(distances.items(), key=operator.itemgetter(1), reverse=True)
        print("closest user:", closest_distance[:n])
        return closest_distance[:n]

    # 给用户推荐电影
    def recommend(self, username, n=3):
        recommend = {}
        nearest_user = self.nearest_user(username, n)
        for user, score in dict(nearest_user).items():
            for movies, scores in self.all_user[user].items():
                if movies not in self.all_user[username].keys():
                    if movies not in recommend.keys():
                        recommend[movies] = scores * score
        return sorted(recommend.items(), key=operator.itemgetter(1), reverse=True)

    # 基于用户的推荐
    def recommend_by_user_id(user_id):
        user_prefer = UserTagPrefer.objects.filter(user_id=user_id).order_by('-score').values_list('tag_id', flat=True)
        current_user = User.objects.get(id=user_id)
        if current_user.rate_set.count() == 0:
            if len(user_prefer) != 0:
                movie_list = Movie.objects.filter(tags__in=user_prefer)[:15]
            else:
                movie_list = Movie.objects.order_by("-num")[:15]
            return movie_list
        users_rate = Rate.objects.values('user').annotate(mark_num=Count('user')).order_by('-mark_num')
        user_ids = [user_rate['user'] for user_rate in users_rate]
        user_ids.append(user_id)
        users = User.objects.filter(id__in=user_ids)
        all_user = {}
        for user in users:
            rates = user.rate_set.all()
            rate = {}
            if rates:
                for i in rates:
                    rate.setdefault(str(i.movie.id), i.mark)
            all_user.setdefault(user.username, rate)
        user_cf = UserCf(all_user=all_user)
        recommend_list = [each[0] for each in user_cf.recommend(current_user.username, 15)]
        movie_list = list(Movie.objects.filter(id__in=recommend_list).order_by("-num")[:15])
        other_length = 15 - len(movie_list)
        if other_length > 0:
            fix_list = Movie.objects.filter(~Q(rate__user_id=user_id)).order_by('-collect')
            for fix in fix_list:
                if fix not in movie_list:
                    movie_list.append(fix)
                if len(movie_list) >= 15:
                    break
        return movie_list

    # 计算相似度
    def similarity(movie1_id, movie2_id):
        movie1_set = Rate.objects.filter(movie_id=movie1_id)
        movie1_sum = movie1_set.count()
        movie2_sum = Rate.objects.filter(movie_id=movie2_id).count()
        common = Rate.objects.filter(user_id__in=Subquery(movie1_set.values('user_id')), movie=movie2_id).values('user_id').count()
        if movie1_sum == 0 or movie2_sum == 0:
            return 0
        similar_value = common / sqrt(movie1_sum * movie2_sum)
        return similar_value

    # 基于物品
    def recommend_by_item_id(user_id, k=15):
        user_prefer = UserTagPrefer.objects.filter(user_id=user_id).order_by('-score').values_list('tag_id', flat=True)
        user_prefer = list(user_prefer)[:3]
        current_user = User.objects.get(id=user_id)
        if current_user.rate_set.count() == 0:
            if len(user_prefer) != 0:
                movie_list = Movie.objects.filter(tags__in=user_prefer)[:15]
            else:
                movie_list = Movie.objects.order_by("-num")[:15]
            print('from here')
            return movie_list
        un_watched = Movie.objects.filter(~Q(rate__user_id=user_id), tags__in=user_prefer).order_by('?')[:30]
        watched = Rate.objects.filter(user_id=user_id).values_list('movie_id', 'mark')
        distances = []
        names = []
        for un_watched_movie in un_watched:
            for watched_movie in watched:
                if un_watched_movie not in names:
                    names.append(un_watched_movie)
                    distances.append((similarity(un_watched_movie.id, watched_movie[0]) * watched_movie[1], un_watched_movie))
        distances.sort(key=lambda x: x[0], reverse=True)
        print('this is distances', distances[:15])
        recommend_list = []
        for mark, movie in distances:
            if len(recommend_list) >= k:
                break
            if movie not in recommend_list:
                recommend_list.append(movie)
        print('recommend list', recommend_list)
        return recommend_list

if __name__ == '__main__':
    similarity(2003, 2008)
    recommend_by_item_id(1)