基于 Django 和 Python 的电影推荐系统，通过协同过滤算法和用户画像聚类算法

基于 Django + Python + MySQL 的电影推荐系统实现，使用了协同过滤算法和用户画像聚类算法，并提供了可视化界面

---

基于 Django 的电影推荐系统，
按照以下步骤进行详细代码的编写。
以下是完整的项目结构和代码示例：

项目结构

Movies_Recommend-master/
├── database
│   └── db.sqlite3
├── movie
│   ├── migrations
│   ├── static
│   │   └── css
│   │       └── style.css
│   ├── templates
│   │   └── movie
│   │       └── index.html
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── context_processors.py
│   ├── forms.py
│   ├── models.py
│   ├── tests.py
│   ├── urls.py
│   └── views.py
├── Movie_recommendation_system
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
├── README.md
└── requirements.txt

数据库设计

models.py

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=50, unique=True)
    password = models.CharField(max_length=255)
    age = models.IntegerField(null=True, blank=True)
    gender = models.CharField(max_length=10, choices=[('male', 'Male'), ('female', 'Female')], null=True, blank=True)
    occupation = models.CharField(max_length=100, null=True, blank=True)

class Movie(models.Model):
    title = models.CharField(max_length=255)
    genres = models.CharField(max_length=255)

class Rating(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    movie = models.ForeignKey(Movie, on_delete=models.CASCADE)
    rating = models.FloatField()

协同过滤算法

recommendation.py

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

class CollaborativeFiltering:
    def __init__(self, ratings_matrix):
        self.ratings_matrix = ratings_matrix

    def recommend_movies(self, user_id, top_n=5):
        # 计算用户相似度矩阵
        similarity_matrix = cosine_similarity(self.ratings_matrix)
        user_similarities = similarity_matrix[user_id]

        # 获取目标用户的评分向量
        user_ratings = self.ratings_matrix[user_id]

        # 加权平均计算推荐分数
        weighted_scores = np.dot(similarity_matrix[user_id], self.ratings_matrix)
        normalized_scores = weighted_scores / (np.sum(np.abs(similarity_matrix[user_id])) + 1e-8)

        # 排除用户已经评分过的电影
        recommendations = [(i, score) for i, score in enumerate(normalized_scores) if user_ratings[i] == 0]
        recommendations.sort(key=lambda x: x[1], reverse=True)

        return recommendations[:top_n]

用户画像聚类算法

clustering.py

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

class UserClustering:
    def __init__(self, user_features):
        self.user_features = user_features

    def cluster_users(self, n_clusters=5):
        scaler = StandardScaler()
        scaled_features = scaler.fit_transform(self.user_features)

        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
        clusters = kmeans.fit_predict(scaled_features)

        return clusters

Django 后端实现

views.py

from django.shortcuts import render
from .models import User, Movie, Rating
from .recommendation import CollaborativeFiltering
from .clustering import UserClustering
import numpy as np

def home(request):
    return render(request, 'movie/index.html')

def recommend(request):
    user_id = int(request.GET.get('user_id'))
    users = User.objects.all()
    movies = Movie.objects.all()
    ratings = Rating.objects.all()

    # 构建评分矩阵
    user_ids = [user.id for user in users]
    movie_ids = [movie.id for movie in movies]
    ratings_matrix = np.zeros((len(user_ids), len(movie_ids)))

    for rating in ratings:
        user_idx = user_ids.index(rating.user.id)
        movie_idx = movie_ids.index(rating.movie.id)
        ratings_matrix[user_idx, movie_idx] = rating.rating

    # 协同过滤推荐
    cf = CollaborativeFiltering(ratings_matrix)
    recommendations = cf.recommend_movies(user_id)

    # 用户画像聚类
    user_features = [[user.age or 0, 1 if user.gender == 'male' else 0] for user in users]
    clustering = UserClustering(user_features)
    clusters = clustering.cluster_users()

    recommended_movies = [movies[idx].title for idx, _ in recommendations]

    return render(request, 'movie/recommendations.html', {
        'recommended_movies': recommended_movies,
        'cluster': clusters[user_id]
    })

前端界面

templates/movie/index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Movie Recommendation</title>
    <link rel="stylesheet" href="/static/css/style.css">
</head>
<body>
    <h1>Movie Recommendation System</h1>
    <form method="get" action="/recommend/">
        <label for="user_id">Enter User ID:</label>
        <input type="number" id="user_id" name="user_id" required>
        <button type="submit">Get Recommendations</button>
    </form>
</body>
</html>

templates/movie/recommendations.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Recommendations</title>
    <link rel="stylesheet" href="/static/css/style.css">
</head>
<body>
    <h1>Recommended Movies</h1>
    <ul>
        {% for movie in recommended_movies %}
            <li>{{ movie }}</li>
        {% endfor %}
    </ul>
    <p>Your Cluster: {{ cluster }}</p>
    <a href="/">Back to Home</a>
</body>
</html>

运行与部署

安装依赖

pip install -r requirements.txt

初始化数据库

python manage.py makemigrations
python manage.py migrate

运行服务器

python manage.py runserver

访问 http://localhost:8000 即可使用系统。

---

总结

基于 Django 和 Python 的电影推荐系统，使用了协同过滤算法和用户画像聚类算法。通过 Django 提供了可视化界面，用户可以输入自己的 ID 并获得个性化的电影推荐。