基于 Flask 与机器学习的电影推荐及票房预测系统

算法实现细节

在票房预测环节，我们并未单一依赖某个模型，而是采用了 Stacking 集成学习策略。具体思路如下：

1. 数据预处理：对票房数据进行 log1p 转换，使其分布更接近正态分布，有利于线性回归类模型的收敛。
2. 基学习器训练：分别训练决策树 (Decision Tree)、Lasso 回归、随机森林 (Random Forest) 和梯度提升树 (GDBT)。每个模型都通过网格搜索 (GridSearchCV) 优化了超参数。
3. 元学习器融合：将上述四个模型的预测结果作为新特征，输入到线性回归 (Linear Regression) 中进行二次训练，从而获得最终的预测值。

这种组合方式能有效降低单一模型的方差与偏差，提高泛化能力。

核心代码解析

以下是票房预测模型训练与集成的关键逻辑。注意数据划分与模型保存路径的处理。

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]
# 标签经过 log1p 转换，使其更偏向于正态分布
y = data.iloc[:, 7].apply(lambda x: x / 10000)
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 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]]]

主程序执行流程如下，依次训练各基模型并测试最终集成效果：

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_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

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