电影推荐与票房预测系统：基于 Python + Flask + 机器学习

（5）电影推荐

提供电影选择的下拉入口，用户选定目标电影后，系统通过推荐算法生成对应的 Top10 推荐列表，以表格形式展示推荐电影的多类信息。帮助用户快速获取匹配偏好的电影内容。

（6）电影信息管理

提供电影信息的查询（支持下拉筛选）与展示功能，以表格呈现电影多类信息，同时为每条数据配备操作按钮。管理员通过该模块实现电影信息的增删管理，保障系统内电影数据的及时更新与有序维护。

（7）用户信息管理

支持通过下拉筛选查询用户信息，以表格展示用户名、类型等内容，同时为每条数据配备操作按钮。管理员通过该模块实现用户信息的查询与维护，保障系统内用户账号的有序管理。

（8）后台数据管理

提供多标签页切换（涵盖电影、票房等数据分类），支持搜索、批量操作及分页浏览，以表格展示数据详情并配备编辑类操作按钮。后台管理员通过该模块实现系统核心数据的集中管理。

（9）注册登录

提供账号、密码的输入框及登录按钮，同时配备注册账号入口。用户通过该模块完成身份验证后，可进入对应角色的功能界面，实现系统的权限区分与安全访问。

3、项目说明

一、技术架构

本项目以 Python 为核心，整合 Flask 框架搭建后端服务，采用 MySQL 数据库完成数据存储。借助 requests 爬虫库采集电影相关数据，通过 Echarts 可视化工具实现数据大屏展示；引入 Surprise 库 KNNWithZScore 算法实现电影推荐、Stacking 集成学习（决策树/Lasso/随机森林/GDBT）提升票房预测精度，搭配 HTML 完成前端页面呈现。

二、功能模块详解

• 数据采集与存储：通过 requests 爬虫采集电影基础信息、票房、评论等原始数据，经清洗规整后存入 MySQL 数据库，保障数据的完整性与结构化。
• 电影票房预测：提供电影选择下拉入口，用户选定影片后，系统调用 Stacking 集成学习算法计算并展示票房预测结果，输出直观的票房参考数据。
• 电影推荐：支持用户通过下拉框选定电影，依托 KNNWithZScore 算法生成 Top10 推荐列表，帮助用户快速获取匹配偏好的电影内容。
• 数据可视化展示：包含电影数据可视化大屏和评论数据可视化大屏，前者呈现电影类型、上映国家、年度趋势等多维度数据，后者展示评论用户数、词云分析、热门电影分布等内容。
• 用户角色与功能分配：通过注册登录环节实现身份验证，划分普通用户、管理员、后台管理员三级角色，不同角色对应不同操作权限。
• 电影信息管理：支持管理员通过下拉筛选查询电影信息，以表格展示数据并配备操作按钮，可完成电影信息的增删管理。
• 用户信息管理：管理员可下拉筛选查询用户信息，通过表格呈现账号信息并进行维护操作。
• 后台数据管理：后台管理员可通过多标签页切换管理电影、票房等核心数据，支持搜索、批量操作及分页浏览。

三、项目总结

本系统构建了'数据采集 - 算法应用 - 功能落地'的全流程闭环。系统依托爬虫与数据库实现数据管理，借助机器学习算法提升推荐与预测的精准度，通过可视化大屏直观呈现多维度数据，同时基于角色分配实现精细化的信息管理。从用户端来看，普通用户可便捷获取个性化推荐、查看票房预测；从管理端来看，管理员可维护电影与用户信息，后台管理员保障数据安全，兼顾了用户体验与行业决策需求。

4、核心代码

在票房预测部分，我们采用了 Stacking 集成策略，先训练多个基模型（决策树、Lasso、随机森林、GDBT），再使用线性回归作为元模型进行融合。以下是具体的模型训练与预测逻辑实现。

import re
import os
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.metrics import make_scorer, mean_squared_error
from sklearn.metrics import r2_score
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.model_selection import KFold
from sklearn.tree import DecisionTreeRegressor
from sklearn.linear_model import LinearRegression as LR, Lasso
import joblib
import seaborn as sns

model_save_path = r'./app/dataset/testModel/'
if not os.path.exists(model_save_path):
    os.makedirs(model_save_path)

data = pd.read_csv(r"./app/dataset/ana_result/piaofang_info.csv")
data = data.iloc[:, [2, 3, 4, 5, 7, 9, 10, 11]]
X = data.iloc[:, 0:7]
y = data.iloc[:, 7].apply(lambda x: x / 10000)  # 标签经过 log1p 转换，使其更偏向于正态分布
y = np.log1p(y)

# 数据集划分
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.2, random_state=1)
oof_df = pd.DataFrame()
test_oof_df = pd.DataFrame()

def performance_metric(y_true, y_predict):
    """ Calculates and returns the performance score between true and predicted values based on the metric chosen. """
    # 计算 'y_true' 与 'y_predict' 的 r2 值
    score = r2_score(y_true, y_predict)
    # 返回这一分数
    return score

def fit_dtr_model(X, y):
    cross_validator = KFold(n_splits=5)
    regressor = DecisionTreeRegressor(random_state=1)
    # Create a dictionary for the parameter 'max_depth' with a range from 1 to 10
    params = {'max_depth': [i for i in range(1, 11)]}
    # Transform 'performance_metric' into a scoring function using 'make_scorer'
    scoring_fnc = make_scorer(performance_metric)
    # Create the grid search cv object --> GridSearchCV()
    grid = GridSearchCV(regressor, params, scoring=scoring_fnc, cv=cross_validator)
    # Fit the grid search object to the data to compute the optimal model
    grid = grid.fit(X, y)
    dtr_max_depth = grid.best_estimator_.get_params()['max_depth']
    # Return the optimal model after fitting the data
    return dtr_max_depth

def fit_decision_tree_model_forcast():
    # 进行决策树预测模型的训练
    dtr_max_depth = fit_dtr_model(X, y)
    dtr_regressor = DecisionTreeRegressor(max_depth=dtr_max_depth)
    dtr_regressor.fit(X, y)
    pred_y = dtr_regressor.predict(test_X)
    test_oof_df['dtr'] = pred_y
    r2_score_val = performance_metric(test_y, pred_y)
    rmse_score = np.sqrt(mean_squared_error(pred_y, test_y))
    print('决策树回归模型评价指标为：')
    print("The R2 score is ", r2_score_val)
    print('均方差', rmse_score)
    joblib.dump(dtr_regressor, model_save_path + 'dtr_model.pkl')
    return rmse_score

def fit_lasso_model_forcast():
    # 进行 Lasso 预测模型的训练
    lasso_regressor = Lasso()
    lasso_regressor.fit(X, y)
    pred_y = lasso_regressor.predict(test_X)
    test_oof_df['lasso'] = pred_y
    r2_score_val = performance_metric(test_y, pred_y)
    rmse_score = np.sqrt(mean_squared_error(pred_y, test_y))
    print('Lasso 回归模型评价指标为：')
    print("The R2 score is ", r2_score_val)
    print('均方差', rmse_score)
    joblib.dump(lasso_regressor, model_save_path + 'lasso_model.pkl')
    return rmse_score

def fit_random_forest_regression_model():
    rf_model = RandomForestRegressor()
    rf_model.fit(X, y)
    pred_y = rf_model.predict(test_X)
    test_oof_df['rf'] = pred_y
    r2_score_val = performance_metric(pred_y, test_y)
    rmse_score = np.sqrt(mean_squared_error(pred_y, test_y))
    print('随机森林模型评价指标为：')
    print("The R2 score is ", r2_score_val)
    print('均方差', rmse_score)
    joblib.dump(rf_model, model_save_path + 'rf_model.pkl')
    return rmse_score

def fit_gdbt_model():
    gdbt_model = GradientBoostingRegressor()
    gdbt_model.fit(X, y)
    pred_y = gdbt_model.predict(test_X)
    test_oof_df['gdbt'] = pred_y
    r2_score_val = performance_metric(pred_y, test_y)
    rmse_score = np.sqrt(mean_squared_error(pred_y, test_y))
    print('GDBT 模型评价指标为：')
    print("The R2 score is ", r2_score_val)
    print('均方差', rmse_score)
    joblib.dump(gdbt_model, model_save_path + 'gdbt_model.pkl')
    return rmse_score

def fit_stacking_model():
    lr_model = LR()
    lr_model.fit(test_oof_df, test_y)
    pred_y = lr_model.predict(test_oof_df)
    r2_score_val = performance_metric(pred_y, test_y)
    rmse_score = np.sqrt(mean_squared_error(pred_y, test_y))
    print('Staking 模型评价指标为：')
    print("The R2 score is ", r2_score_val)
    print('均方差', rmse_score)
    joblib.dump(lr_model, model_save_path + 'stacking_model.pkl')
    return rmse_score

def forecast_piaofang(para):
    para = pd.DataFrame(para)
    # 加载决策树预测模型
    dtr_model = joblib.load(model_save_path + 'dtr_model.pkl')
    dtr_pred = dtr_model.predict(para)
    print("决策树预测票房%s万" % np.expm1(dtr_pred[0]))
    # 加载 Lasso 预测模型
    lasso_model = joblib.load(model_save_path + 'lasso_model.pkl')
    lasso_pred = lasso_model.predict(para)
    print("Lasso 预测票房%s万" % np.expm1(lasso_pred[0]))
    # 加载随机森林预测模型
    rf_model = joblib.load(model_save_path + 'rf_model.pkl')
    rf_pred = rf_model.predict(para)
    print("随机森林预测票房%s万" % np.expm1(rf_pred[0]))
    # 加载 GDBT 预测模型
    gdbt_model = joblib.load(model_save_path + 'gdbt_model.pkl')
    gdbt_pred = gdbt_model.predict(para)
    print("GDBT 预测票房%s万" % np.expm1(gdbt_pred[0]))
    return [[dtr_pred[0], lasso_pred[0], rf_pred[0], gdbt_pred[0]]]

为了对比各模型效果，我们编写了训练脚本，将 RMSE 结果保存至 CSV 文件，并在主程序中执行测试与分析。

# 用于训练多个模型并计算它们的 RMSE（均方根误差）分数，并将结果保存到一个 CSV 文件中。
def train_model():
    dtr_rmse = fit_decision_tree_model_forcast()  # 决策树
    lasso_rmse = fit_lasso_model_forcast()  # Lasso
    rf_rmse = fit_random_forest_regression_model()  # 随机森林
    gdbt_rmse = fit_gdbt_model()  # GDBT
    lr_rmse = fit_stacking_model()  # 将返回的堆叠模型的 RMSE 分数赋值给变量
    rmse_result = pd.DataFrame(index=["决策树", "Lasso", "随机森林", "GDBT", "Stacking"])
    rmse_result['rmse_score'] = [dtr_rmse, lasso_rmse, rf_rmse, gdbt_rmse, lr_rmse]
    # 将之前计算得到的各个模型的 RMSE 分数添加到 rmse_result 数据帧中的 rmse_score 列中。
    rmse_result.to_csv("../dataset/testModel/rmse_result.csv", encoding='utf-8', index=False)
    # 将 rmse_result 数据帧保存为一个 CSV 文件

def test_model():
    # 1965, 12, 8.9, 1, 3, 29, 132
    # 1295124,辛德勒的名单，1993,11,9.6,3,"['剧情', '历史', '战争']",1,['美国'],48,195,322161245
    # 10876425,印式英语，2023,02,8.1,3,"['剧情', '喜剧', '家庭']",1,['印度'],13,133,10299150
    # 35267208,流浪地球 2,2023,01,8.4,3,"['科幻', '冒险', '灾难']",1,['中国大陆'],50,173,8394962
    test_para = pd.DataFrame([[2022, 2, 8.4, 3, 1, 50, 173]])
    test_piaofang = 8394962 / 10000
    print("真实票房%s万" % test_piaofang)
    pred_list = forecast_piaofang(test_para)
    # 加载线性回归预测模型
    stacking_model = joblib.load(model_save_path + 'stacking_model.pkl')
    piaofang = stacking_model.predict(pred_list)[0]
    piaofang = round(np.expm1(piaofang), 2)
    print("Stacking 预测票房%s万" % piaofang)
    return piaofang

def forecast(para_list):
    # 根据传入的参数列表，进行票房预测
    pred_list = forecast_piaofang(para_list)
    # 加载线性回归预测模型
    stacking_model = joblib.load(model_save_path + 'stacking_model.pkl')
    piaofang = stacking_model.predict(pred_list)[0]
    piaofang = round(np.expm1(piaofang), 2)
    print("Stacking 预测票房%s万" % piaofang)
    return "预测票房%s万 (美元)" % piaofang

def vis_relation(x1, y1, name1):
    fig = plt.figure(1, figsize=(9, 5))
    # plt.plot([0,400000000],[0,400000000],c="green")
    plt.scatter(x1, y1, c=['green'], marker='o')
    plt.grid()
    plt.xlabel("piaofang", fontsize=10)
    plt.ylabel(name1, fontsize=10)
    plt.title("Link between piaofang and %s" % name1, fontsize=10)
    plt.savefig('../dataset/pictures/piaofang_%s.png' % name1)
    plt.close()

# 分析票房预测使用的所有属性与票房之间的关系并绘制散点图，分析所有属性之间的相关度绘制热力图
def ana_columns():
    year_list = list(data.iloc[:, 0])
    month_list = list(data.iloc[:, 1])
    rating_list = list(data.iloc[:, 2])
    movie_type_count_list = list(data.iloc[:, 3])
    country_count_list = list(data.iloc[:, 4])
    actor_count_list = list(data.iloc[:, 5])
    runtime_list = list(data.iloc[:, 6])
    piaofang_list = list(data.iloc[:, 7])
    vis_relation(piaofang_list, year_list, 'year')
    vis_relation(piaofang_list, month_list, 'month')
    vis_relation(piaofang_list, rating_list, 'rating')
    vis_relation(piaofang_list, movie_type_count_list, 'movie_type_count')
    vis_relation(piaofang_list, country_count_list, 'country_count')
    vis_relation(piaofang_list, actor_count_list, 'actor_count')
    vis_relation(piaofang_list, runtime_list, 'runtime')
    # 相关关系可视化
    col = ['year', 'month', 'rating', 'movie_type_count', 'country_count', 'actor_count', 'runtime', 'piaofang']
    plt.subplots(figsize=(14, 10))
    corr = data.corr()
    print(corr)
    corr.to_csv("../dataset/ana_result/piaofang_info_corr.csv", encoding='utf-8')
    sns.heatmap(corr, xticklabels=col, yticklabels=col, linewidths=.5, cmap="Reds")
    plt.savefig('../dataset/pictures/corr.png')

if __name__ == '__main__':
    # 四个机器学习算法构建票房预测模型，然后 Stacking 集成所有的算法模型，构建最终的票房预测模型
    train_model()
    # 模型测试
    piaofang = test_model()
    # 分析票房预测使用的所有属性与票房之间的关系并绘制散点图，分析所有属性之间的相关度绘制热力图
    ana_columns()