def grid_search_model_group():
    # random_forest_regressor模型调用
    grid_rf_score, process_time_rf, best_params_rf = grid_RandomForestRegressor(
        X, y)
    model_name = 'random_forest_regressor'
    hyper_optimize = 'grid_search'
    message = "model_name: {}, hyper_optimize: {}, grid_rf_score: {}, process_time_rf: {},best_params_rf:{}".format(
        model_name, hyper_optimize, grid_rf_score, process_time_rf,
        best_params_rf)
    log_output(message)

    # svr模型调用
    grid_svr_score, process_time_svr, best_params_svr = grid_svr(X, y)
    model_name = 'SVR'
    hyper_optimize = 'grid_search'
    message = "model_name: {}, hyper_optimize: {}, grid_svr_score: {}, process_time_svr: {},best_params_svr:{}".format(
        model_name, hyper_optimize, grid_svr_score, process_time_svr,
        best_params_svr)
    log_output(message)

    # knn模型调用
    grid_knn_score, process_time_knn, best_params_knn = grid_knn(X, y)
    model_name = 'KNN'
    hyper_optimize = 'grid_search'
    message = "model_name: {}, hyper_optimize: {}, grid_knn_score: {}, process_time_knn: {},best_params_knn:{}".format(
        model_name, hyper_optimize, grid_knn_score, process_time_knn,
        best_params_knn)
    log_output(message)

    # ann模型调用
    grid_ann_score, process_time_ann, best_params_ann = grid_ANN(X, y)
    model_name = 'ANN'
    hyper_optimize = 'grid_search'
    message = "model_name: {}, hyper_optimize: {}, grid_ann_score: {}, process_time_ann: {},best_params_ann:{}".format(
        model_name, hyper_optimize, grid_ann_score, process_time_ann,
        best_params_ann)
    log_output(message)

    score = [
        'gridsearch_score', grid_rf_score, grid_svr_score, grid_knn_score,
        grid_ann_score
    ]
    process_time = [
        'gridsearch_process_time', process_time_rf, process_time_svr,
        process_time_knn, process_time_ann
    ]
    gridsearch_score = [score, process_time]
    gridsearch_score_df = pd.DataFrame(data=gridsearch_score,
                                       columns=[
                                           'description',
                                           'RandomForestRegressor', 'SVR',
                                           'KNeighborsRegressor', 'ANN'
                                       ])
    gridsearch_score_df.set_index('description', inplace=True)
    save_record_object(gridsearch_score_df, 'grid_search',
                       'gridsearch_score_df')
def bo_gp_model_group():
    # random_forest_regressor模型调用
    bo_rf_score, process_time_rf, best_params_rf = bo_RandomForestRegressor(
        X, y)
    model_name = 'random_forest_regressor'
    hyper_optimize = 'BO-GP'
    message = "model_name: {}, hyper_optimize: {}, bo_rf_score: {}, process_time_rf: {},best_params_rf:{}".format(
        model_name, hyper_optimize, bo_rf_score, process_time_rf,
        best_params_rf)
    log_output(message)

    # svr模型调用
    bo_svr_score, process_time_svr, best_params_svr = bo_svr(X, y)
    model_name = 'SVR'
    hyper_optimize = 'BO-GP'
    message = "model_name: {}, hyper_optimize: {}, bo_svr_score: {}, process_time_svr: {},best_params_svr:{}".format(
        model_name, hyper_optimize, bo_svr_score, process_time_svr,
        best_params_svr)
    log_output(message)

    # knn模型调用
    bo_knn_score, process_time_knn, best_params_knn = bo_knn(X, y)
    model_name = 'KNN'
    hyper_optimize = 'BO-GP'
    message = "model_name: {}, hyper_optimize: {}, bo_knn_score: {}, process_time_knn: {},best_params_knn:{}".format(
        model_name, hyper_optimize, bo_knn_score, process_time_knn,
        best_params_knn)
    log_output(message)

    # ann模型调用
    bo_ann_score, process_time_ann, best_params_ann = bo_ANN(X, y)
    model_name = 'ANN'
    hyper_optimize = 'BO-GP'
    message = "model_name: {}, hyper_optimize: {}, bo_ann_score: {}, process_time_ann: {},best_params_ann:{}".format(
        model_name, hyper_optimize, bo_ann_score, process_time_ann,
        best_params_ann)
    log_output(message)

    score = ['bo_score', bo_rf_score, bo_svr_score, bo_knn_score, bo_ann_score]
    process_time = [
        'bo_process_time', process_time_rf, process_time_svr, process_time_knn,
        process_time_ann
    ]
    bo_score = [score, process_time]
    bo_score_df = pd.DataFrame(data=bo_score,
                               columns=[
                                   'description', 'RandomForestRegressor',
                                   'SVR', 'KNeighborsRegressor', 'ANN'
                               ])
    bo_score_df.set_index('description', inplace=True)
    save_record_object(bo_score_df, 'BO-GP', 'bo_score_df')
def optuna_model_group():
    # random_forest_regressor模型调用
    optuna_rf_score, process_time_rf, best_params_rf = optuna_RandomForestRegressor(
        X, y)
    model_name = 'random_forest_regressor'
    hyper_optimize = 'Optuna'
    message = "model_name: {}, hyper_optimize: {}, optuna_rf_score: {}, process_time_rf: {},best_params_rf:{}".format(
        model_name, hyper_optimize, optuna_rf_score, process_time_rf,
        best_params_rf)
    log_output(message)

    # svr模型调用
    optuna_svr_score, process_time_svr, best_params_svr = optuna_svr(X, y)
    model_name = 'SVR'
    hyper_optimize = 'Optuna'
    message = "model_name: {}, hyper_optimize: {}, optuna_svr_score: {}, process_time_svr: {},best_params_svr:{}".format(
        model_name, hyper_optimize, optuna_svr_score, process_time_svr,
        best_params_svr)
    log_output(message)

    # knn模型调用
    optuna_knn_score, process_time_knn, best_params_knn = optuna_knn(X, y)
    model_name = 'KNN'
    hyper_optimize = 'Optuna'
    message = "model_name: {}, hyper_optimize: {}, optuna_knn_score: {}, process_time_knn: {},best_params_knn:{}".format(
        model_name, hyper_optimize, optuna_knn_score, process_time_knn,
        best_params_knn)
    log_output(message)

    # # ann模型调用
    optuna_ann_score, process_time_ann, best_params_ann = optuna_ANN(X, y)
    model_name = 'ANN'
    hyper_optimize = 'Optuna'
    message = "model_name: {}, hyper_optimize: {}, optuna_ann_score: {}, process_time_ann: {},best_params_ann:{}".format(
        model_name, hyper_optimize, optuna_ann_score, process_time_ann,
        best_params_ann)
    log_output(message)

    # GradientBoostingRegressor模型调用
    optuna_gbr_score, process_time_gbr, best_params_gbr = optuna_GradientBoostingRegressor(
        X, y)
    model_name = 'GradientBoostingRegressor'
    hyper_optimize = 'Optuna'
    message = "model_name: {}, hyper_optimize: {}, optuna_gbr_score: {}, process_time_gbr: {},best_params_gbr:{}".format(
        model_name, hyper_optimize, optuna_gbr_score, process_time_gbr,
        best_params_gbr)
    log_output(message)

    # xgb模型调用
    optuna_xgb_score, process_time_xgb, best_params_xgb = optuna_xgb(X, y)
    model_name = 'XGBoost'
    hyper_optimize = 'Optuna'
    message = "model_name: {}, hyper_optimize: {}, optuna_xgb_score: {}, process_time_xgb: {},best_params_xgb:{}".format(
        model_name, hyper_optimize, optuna_xgb_score, process_time_xgb,
        best_params_xgb)
    log_output(message)

    # lightgbm模型调用
    optuna_lgb_score, process_time_lgb, best_params_lgb = optuna_lightgbm(X, y)
    model_name = 'LightGBM'
    hyper_optimize = 'Optuna'
    message = "model_name: {}, hyper_optimize: {}, optuna_lgb_score: {}, process_time_lgb: {},best_params_lgb:{}".format(
        model_name, hyper_optimize, optuna_lgb_score, process_time_lgb,
        best_params_lgb)
    log_output(message)

    score = [
        'Optuna_score', optuna_rf_score, optuna_gbr_score, optuna_ann_score,
        optuna_svr_score, optuna_knn_score, optuna_xgb_score, optuna_lgb_score
    ]

    process_time = [
        'Optuna_process_time', process_time_rf, process_time_gbr,
        process_time_ann, process_time_svr, process_time_knn, process_time_xgb,
        process_time_lgb
    ]
    Optuna_score = [score, process_time]
    Optuna_score_df = pd.DataFrame(data=Optuna_score,
                                   columns=[
                                       'description', 'RandomForestRegressor',
                                       'GradientBoostingRegressor', 'ANN',
                                       'SVR', 'KNeighborsRegressor', 'XGboost',
                                       'LightGBM'
                                   ])
    Optuna_score_df.set_index('description', inplace=True)
    save_record_object(Optuna_score_df, 'Optuna', 'Optuna_score_df')
def bo_tpe_model_group():
    # random_forest_regressor模型调用
    bo_tpe_rf_score, process_time_rf, best_params_rf = bo_tpe_RandomForestRegressor(
        X, y)
    model_name = 'random_forest_regressor'
    hyper_optimize = 'BO-TPE'
    message = "model_name: {}, hyper_optimize: {}, bo_tpe_rf_score: {}, process_time_rf: {},best_params_rf:{}".format(
        model_name, hyper_optimize, bo_tpe_rf_score, process_time_rf,
        best_params_rf)
    log_output(message)

    # svr模型调用
    bo_tpe_svr_score, process_time_svr, best_params_svr = bo_tpe_svr(X, y)
    model_name = 'SVR'
    hyper_optimize = 'BO-TPE'
    message = "model_name: {}, hyper_optimize: {}, bo_tpe_svr_score: {}, process_time_svr: {},best_params_svr:{}".format(
        model_name, hyper_optimize, bo_tpe_svr_score, process_time_svr,
        best_params_svr)
    log_output(message)

    # knn模型调用
    bo_tpe_knn_score, process_time_knn, best_params_knn = bo_tpe_knn(X, y)
    model_name = 'KNN'
    hyper_optimize = 'BO-TPE'
    message = "model_name: {}, hyper_optimize: {}, bo_tpe_knn_score: {}, process_time_knn: {},best_params_knn:{}".format(
        model_name, hyper_optimize, bo_tpe_knn_score, process_time_knn,
        best_params_knn)
    log_output(message)

    # ann模型调用
    bo_tpe_ann_score, process_time_ann, best_params_ann = bo_tpe_ANN(X, y)
    model_name = 'ANN'
    hyper_optimize = 'BO-TPE'
    message = "model_name: {}, hyper_optimize: {}, bo_tpe_ann_score: {}, process_time_ann: {},best_params_ann:{}".format(
        model_name, hyper_optimize, bo_tpe_ann_score, process_time_ann,
        best_params_ann)
    log_output(message)

    # ngb模型调用
    bo_tpe_ngb_score, process_time_ngb, best_params_ngb = bo_tpe_ngb(X, y)
    model_name = 'NGBoost'
    hyper_optimize = 'BO-TPE'
    message = "model_name: {}, hyper_optimize: {}, bo_tpe_ngb_score: {}, process_time_ngb: {},best_params_ngb:{}".format(
        model_name, hyper_optimize, bo_tpe_ngb_score, process_time_ngb,
        best_params_ngb)
    log_output(message)

    # lgb模型调用
    bo_tpe_lgb_score, process_time_lgb, best_params_lgb = bo_tpe_lightgbm(X, y)
    model_name = 'LightGBM'
    hyper_optimize = 'BO-TPE'
    message = "model_name: {}, hyper_optimize: {}, bo_tpe_gmb_score: {}, process_time_gbm: {},best_params_lgb:{}".format(
        model_name, hyper_optimize, bo_tpe_lgb_score, process_time_lgb,
        best_params_lgb)
    log_output(message)

    score = [
        'BO-TPE_score', bo_tpe_rf_score, bo_tpe_svr_score, bo_tpe_knn_score,
        bo_tpe_ann_score, bo_tpe_ngb_score, bo_tpe_lgb_score
    ]
    process_time = [
        'BO-TPE_process_time', process_time_rf, process_time_svr,
        process_time_knn, process_time_ann, process_time_ngb, process_time_lgb
    ]
    BO_TPE_score = [score, process_time]
    BO_TPE_score_df = pd.DataFrame(data=BO_TPE_score,
                                   columns=[
                                       'description', 'RandomForestRegressor',
                                       'SVR', 'KNeighborsRegressor', 'ANN',
                                       'NGBoost', 'LightGBM'
                                   ])
    BO_TPE_score_df.set_index('description', inplace=True)
    save_record_object(BO_TPE_score_df, 'BO-TPE', 'BO_TPE_score_df')