基于知识图谱的电影推荐问答系统 Python Django Neo4j

（7）后台管理

展示电影信息列表，包含电影名称、类型、评分等内容，支持对电影信息进行添加、删除操作，同时左侧设有功能导航栏，可切换至不同管理模块，辅助管理员管控系统内的电影数据。

3、核心代码

# -*- coding = utf-8 -*-
""" User-based Collaborative filtering. """
import collections
from operator import itemgetter
import math
from collections import defaultdict
from . import similarity
from . import utils
from .utils import LogTime

class UserBasedCF:
    """ User-based Collaborative filtering. Top-N recommendation. """
    def __init__(self, k_sim_user=20, n_rec_movie=10, use_iif_similarity=False, save_model=True):
        """ Init UserBasedCF with n_sim_user and n_rec_movie.
        @return: None
        """
        print("UserBasedCF start...\n")
        self.k_sim_user = k_sim_user
        self.n_rec_movie = n_rec_movie
        self.trainset = None
        self.save_model = save_model
        self.use_iif_similarity = use_iif_similarity

    def fit(self, trainset):
        """ Fit the trainset by calculate user similarity matrix.
        @param trainset: train dataset
        @return: None
        """
        model_manager = utils.ModelManager()
        try:
            self.user_sim_mat = model_manager.load_model('user_sim_mat-iif' if self.use_iif_similarity else 'user_sim_mat')
            self.movie_popular = model_manager.load_model('movie_popular')
            self.movie_count = model_manager.load_model('movie_count')
            self.trainset = model_manager.load_model('trainset')
            print('User origin similarity model has saved before.\nLoad model success...\n')
        except OSError:
            print('No model saved before.\nTrain a new model...')
            self.user_sim_mat, self.movie_popular, self.movie_count = \
                similarity.calculate_user_similarity(trainset=trainset, use_iif_similarity=self.use_iif_similarity)
            self.trainset = trainset
            print('Train a new model success.')
        if self.save_model:
            model_manager.save_model(self.user_sim_mat,'user_sim_mat-iif' if self.use_iif_similarity else 'user_sim_mat')
            model_manager.save_model(self.movie_popular,'movie_popular')
            model_manager.save_model(self.movie_count,'movie_count')
            print('The new model has saved success.\n')

    def recommend(self, user):
        """ Find K similar users and recommend N movies for the user.
        @param user: The user we recommend movies to.
        @return: the N best score movies
        """
        if not self.user_sim_mat or not self.n_rec_movie or \
           not self.trainset or not self.movie_popular or not self.movie_count:
            raise NotImplementedError('UserCF has not init or fit method has not called yet.')
        K = self.k_sim_user
        N = self.n_rec_movie
        predict_score = collections.defaultdict(int)
        if user not in self.trainset:
            print('The user (%s) not in trainset.' % user)
            return
        watched_movies = self.trainset[user]
        for similar_user, similarity_factor in sorted(self.user_sim_mat[user].items(), key=itemgetter(1), reverse=True)[0:K]:
            for movie, rating in self.trainset[similar_user].items():
                if movie in watched_movies:
                    continue
                # predict the user's "interest" for each movie
                # the predict_score is sum(similarity_factor * rating) 预测分数为加权（相似度*评分）求和
                predict_score[movie] += similarity_factor * rating
        # return the N best score movies
        return [movie for movie, _ in sorted(predict_score.items(), key=itemgetter(1), reverse=True)[0:N]]

    def test(self, testset):
        """ Test the recommendation system by recommending scores to all users in testset.
        @param testset: test dataset
        @return: """
        if not self.n_rec_movie or not self.trainset or not self.movie_popular or not self.movie_count:
            raise ValueError('UserCF has not init or fit method has not called yet.')
        self.testset = testset
        print('Test recommendation system start...')
        N = self.n_rec_movie
        hit = 0
        rec_count = 0
        test_count = 0
        all_rec_movies = set()
        popular_sum = 0
        test_time = LogTime(print_step=1000)
        for i, user in enumerate(self.trainset):
            test_movies = self.testset.get(user, {})
            rec_movies = self.recommend(user)
            for movie in rec_movies:
                if movie in test_movies:
                    hit += 1
                    all_rec_movies.add(movie)
                    popular_sum += math.log(1 + self.movie_popular[movie])
                rec_count += N
                test_count += len(test_movies)
            test_time.count_time()
        precision = hit / (1.0 * rec_count)
        recall = hit / (1.0 * test_count)
        coverage = len(all_rec_movies) / (1.0 * self.movie_count)
        popularity = popular_sum / (1.0 * rec_count)
        print('Test recommendation system success.')
        test_time.finish()
        print('precision=%.4f\trecall=%.4f\tcoverage=%.4f\tpopularity=%.4f\n' % (precision, recall, coverage, popularity))

    def predict(self, testset):
        """ Recommend movies to all users in testset.
        :param testset: test dataset
        :return: `dict` : recommend list for each user.
        """
        movies_recommend = defaultdict(list)
        print('Predict scores start...')
        predict_time = LogTime(print_step=500)
        for i, user in enumerate(testset):
            rec_movies = self.recommend(user)
            movies_recommend[user].append(rec_movies)
            predict_time.count_time()
        print('Predict scores success.')
        predict_time.finish()
        return movies_recommend

4、项目总结

本基于知识图谱的电影推荐问答系统，针对性解决了传统电影信息获取与推荐方式的低效问题。技术层面融合多类主流技术，后端依托 Python+Django 保障系统稳定，Neo4j 与 MySQL 双数据库协同实现数据高效存储与关联查询，协同过滤算法提升推荐精准度；功能层面覆盖用户从注册登录到信息查询、问答交互、观影推荐的全流程需求，同时为管理员提供便捷的后台数据管控能力。系统前端适配多终端，操作直观易用，通过知识图谱与推荐算法的结合，既实现了电影信息的高效查询与问答，又能为用户推送个性化内容，大幅提升了用户体验，圆满达成了项目预期目标。