基于 Python Flask 的电影推荐与票房预测系统

5. 电影推荐功能

根据选定电影生成 Top10 推荐列表，以表格形式展示详情，满足个性化选片需求。

6. 电影信息管理

管理员可通过下拉筛选查询电影信息，借助操作按钮完成数据增删，保障数据及时更新。

7. 用户信息管理

支持筛选查询用户信息，维护用户账号，实现有序管理。

8. 后台数据管理

提供多标签页分类管理，支持搜索、批量操作及分页浏览，保障系统数据完整。

9. 注册登录

作为系统访问入口，完成身份验证后进入对应角色的功能界面。

核心代码实现

数据预处理与模型训练

在票房预测模块中，我们首先对数据进行清洗和特征工程。为了适应正态分布，对票房标签进行了 log1p 转换。接着划分训练集和测试集，准备进行模型评估。

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)
    params = {'max_depth': [i for i in range(1, 11)]}
    scoring_fnc = make_scorer(performance_metric)
    grid = GridSearchCV(regressor, params, scoring=scoring_fnc, cv=cross_validator)
    grid = grid.fit(X, y)
    dtr_max_depth = grid.best_estimator_.get_params()['max_depth']
    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_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 forcast_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]]]

模型训练与测试流程

为了构建最终的 Stacking 模型，我们需要先训练多个基模型并保存它们的 RMSE 分数。这里展示了如何组合这些模型并进行最终预测。

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()                # Stacking
    
    rmse_result = pd.DataFrame(index=["决策树", "Lasso", "随机森林", "GDBT", "Stacking"])
    rmse_result['rmse_score'] = [dtr_rmse, lasso_rmse, rf_rmse, gdbt_rmse, lr_rmse]
    rmse_result.to_csv("../dataset/testModel/rmse_result.csv", encoding='utf-8', index=False)

def test_model():
    # 示例参数：年份，月份，评分，类型数量，国家数量，演员数量，时长
    test_para = pd.DataFrame([[2022, 2, 8.4, 3, 1, 50, 173]])
    test_piaofang = 8394962 / 10000
    print("真实票房%s万" % test_piaofang)
    
    pred_list = forcast_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 vis_relation(x1, y1, name1):
    fig = plt.figure(1, figsize=(9, 5))
    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__':
    train_model()
    piaofang = test_model()
    ana_columns()

总结

本系统通过爬虫与数据库完成数据基础搭建，利用集成学习和推荐算法实现核心功能，借助可视化大屏直观呈现数据。既满足普通用户个性化推荐、查看数据的需求，也为行业提供票房预测参考，同时通过完善的信息管理模块保障数据时效性，兼顾用户体验与行业决策需求。