零基础实现高质量数据挖掘（模型分析篇）

# 首先定义一下之前data_flow用过的参数，便于后续直接调用
data_params = {
    "response": "target",  # 基础定义
    "split_col_name": "birth_year", "use_train_time": True,  # 时间切片
    "add_info": "ID",  # 主键添加
    "enable_single_threshold": False,  # 关闭单一值过滤
    # enable_iv_limit=True, iv_threshold=[0.01, np.inf],  # 暂不启用iv过滤
    "customized_groups": {
        "OCCUPATION_TYPE": [
            "Cleaning staff|Cooking staff|Drivers|Laborers|Low-skill Laborers|Security staff|Waiters/barmen staff",
            "Accountants|Core staff|HR staff|Medicine staff|Private service staff|Realty agents|Sales staff|Secretaries",
            "Managers|High skill tech staff|IT staff",
        ],
        "CNT_CHILDREN": [-np.inf, 0, np.inf],
    },
    "exclude_column": ["ID", "weight"],  # 排除权重
    "min_group_percent": 0,
}

at.Analysis.model_on_data(
    df_train, "./模型分析demo/v12/v12.xlsx", test_data=df_test,
    data_flow={
        **data_params,
        **{
            "save_or_return": False  # 跳过csv的io读写提升性能
        },
    },
    model_flow={
        # 默认流程即为评分卡建模，采用statsmodels的逻辑回归
        "model_type_path": "statsmodels.api.Logit"
    }
)

at.Analysis.model_flow(
    df_train, "./模型分析demo/v1-lgb/v1-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
)

    # 基础定义
    # test_data                         选填，默认None，对应的测试数据或验证数据
    # task_type                         选填，默认"binary"，任务类型，可条件性修改
    # exclude_column                    选填，默认None，排除的数据的列，支持str和list
    # flow_data_type                    选填，默认"WOE_"，可选"ORI_"，数据选取的关键字
    # xlsx_must_exists                  选填，默认False，output_name关联的excel不存在时会报错
    # sample_weight_name                选填，默认None，输入后来指定使用某一列的数值调整样本权重
    # auto_convert_dtype                选填，默认True，将train_data和test_data每列数据类型转化一致
    # search_recover_path               选填，默认True，当data为None时候，是否在搜索时包含recover路径
    # slient_performance_warning        选填，默认True，建模时忽略pd.errors.PerformanceWarning的warning

    # 模型定义
    # model_type_path                   选填，默认"statsmodels.api.Logit"，采用标准逻辑回归
    # auto_set_params                   选填，默认True，按预处理和模型特性等自动填充模型参数
    # auto_resize_score                 选填，默认True，检测分数与目标关系，部分评估进行尺度调整
    # slient_model_warn                 选填，默认True，忽略训练预测时，因调用三方模块生成的消息

    # 缺失值处理
    # nan_mode                          选填，默认None，可选min/max/mean/median
    # allow_nan                         选填，默认False，是否允许有缺失值，自动调整

    # 离散值处理
    # allow_discrete                    选填，默认False，是否允许有离散值，自动调整项
    # one_hot_xgboost                   选填，默认False，当模型为xgboost时，所有离散值OH处理
    # one_hot_catboost                  选填，默认False，当模型为catboost时，所有离散值OH处理
    # max_discrete_num                  选填，默认100，支持的离散类型变量的唯一值的上限的个数

at.Analysis.model_flow(
    df_train, "./模型分析demo/v2-lr/v2-lr.xlsx", test_data=df_test,
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight", "DAYS_BIRTH"],  # 排除权重
    add_info="ID",  # 主键添加
    task_type="regression",  # 调整为 regression
    # 非分类器会自动把 convert_score 调整为 False
    model_type_path="sklearn.linear_model.LinearRegression",
)

at.Analysis.model_on_data(
    df_train, "./模型分析demo/v1-scorecard-more/v1-scorecard-more.xlsx",
    # 同时入参两个数据集：测试、全量
    test_data=[df_test, df_data], train_name="开发", test_names=["测试", "全量"],
    data_flow={
        **data_params,
        **{
            "save_or_return": False  # 跳过csv的io读写提升性能
        },
    },
    model_flow={
        # 默认流程即为评分卡建模，采用statsmodels的逻辑回归
        "model_type_path": "statsmodels.api.Logit"
    }
)

at.Analysis.model_flow(
    df_train, "./模型分析demo/v1-lgb-more/v1-lgb-more.xlsx", 
    test_data=[df_test, df_data], train_name="开发", test_names=["测试", "全量"],
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
)

    # 模型定义
    # filter_variable                   选填，默认True，是否对读取数据的变量进行算法筛选
    # is_inherit_tree_model             选填，默认True，传递树模型model_type_path到limit_var_method和imp_filter_method
    
    # 自定义筛选顺序和范围
    # linear_filter_order               选填，默认["corr", "zero", "lasso", "stepwise", "rank"]，线性建模的筛选顺序
    # model_filter_order                选填，默认["corr", "zero", "rank"]，自定义建模流程的筛选顺序

at.Analysis.model_flow(
    df_train, "./模型分析demo/v3-lgb/v3-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    model_filter_order=["corr", "rank"],
)

    # 相关性筛选
    # enable_corr_filter                选填，默认True，是否对全局变量进行相关性筛选
    # corr_filter_limit                 选填，默认0.65，启用相关性筛选时的变量筛选阈值
    # corr_pvalue_limit                 选填，默认None，建议可选范围0.001/0.01/0.05/0.1
    # slient_corr_warn                  选填，默认True，忽略相关性分析输出的warnings消息
    # select_corr_by                    选填，默认["iv_train", False]，使用的列和是否升序
    # corr_method                       选填，默认"pearsonr"，可选"kendalltau"/"spearmanr"

discrete_cols = df_train.dtypes[df_train.dtypes == object].index.tolist()
at.Analysis.model_flow(
    df_train, "./模型分析demo/v4-lgb/v4-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"] + discrete_cols,  # 排除权重和离散值
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
)

    # 重要性筛选
    # zero_imp_filter                   选填，默认True，是否对全局变量进行重要性非零筛选
    # imp_filter_method                 选填，默认"lightgbm.sklearn.LGBMClassifier"
    # imp_method_parameter              选填，默认{}，继承"tree_default_params"

    # 正则化筛选
    # enable_lasso_filter               选填，默认False，使用lasso对变量进行降维

    # 逐步回归模式
    # enable_stepwise                   选填，默认True，是否启用逐步回归
    # stepwise_method                   选填，默认"forward"前向逐步回归，可选"backward"
    # forward_round_num                 选填，默认3，forward回归时遍历所有变量的次数，不可超过10

    # 逐步回归显著性筛选
    # enable_pvalue_filter              选填，默认True，是否启用显著性筛选
    # pvalue_filter_limit               选填，默认0.05，显著性筛选时的筛选阈值

    # 逐步回归模型系数筛选
    # enable_coef_negative              选填，默认{"WOE_": True, "ORI_": None, "": None}，控制coef的方向
    # check_coef_consistency            选填，默认{"WOE_": False, "ORI_": True, "": True}，变量coef一致性检验

    # 线性模型参数
    # use_fstatistic_pvalue             选填，默认True，使用sklearn线性模型时，使用ftest的pvalue替换

at.Analysis.model_on_data(
    df_train, "./模型分析demo/v5-gls/v5-gls.xlsx", test_data=df_test,
    data_flow={
        **data_params,
        **{
            "save_ori": True,  # 数据集仅保留原始数据，会自动添加"ORI_"
            "save_or_return": False  # 跳过csv的io读写提升性能
        },
    },
    model_flow={
        # 更换模型，非discrete模型会自动关闭convert_score
        "model_type_path": "statsmodels.api.GLS",
        "pvalue_filter_limit": 0.5,  # 变量较少，此处调整pvalue阈值避免无变量
        # stepwise时按ORI_，enable_coef_negative取None跳过，check_coef_consistency取True开启
        "model_filter_order": ["corr", "stepwise"],
    }
)

    # 变量数量限制
    # limit_var_num                     选填，默认20，通过树模型重要性，限制最终进入模型的变量的个数
    # limit_var_method                  选填，默认"lightgbm.sklearn.LGBMClassifier"，需要树模型
    # limit_method_parameter            选填，默认{}，继承"tree_default_params"

    # 线性模型参数
    # auto_add_intercept                选填，默认True，当检测为statsmodels模型时自动添加截距项
    # auto_singular_matrix              选填，默认True，statsmodels时，自动处理奇异矩阵不可逆问题
    # display_linear_pvalue             选填，默认True，使用sklearn线性模型时，是否展示模型pvalue

    # 线性模型参数
    # vif_include_intercept             选填，默认True，VIF值计算包含截距，statsmodels作者推荐包含截距
    # vif_display_intercept             选填，默认False，vif_include_intercept为True时，展示是否包含截距

    # 模型定义
    # customized_variables              选填，默认[]，设定变量列表来定制建模，入参后跳过变量筛选步骤
    # customized_parameter              选填，默认{}，建模方法的入参字典，可配合参数搜索来做定制使用
    # model_func_definition             选填，默认None，默认自动按model_type_path配置调整，不建议入参

discrete_cols = df_train.dtypes[df_train.dtypes == object].index.tolist()
at.Analysis.model_flow(
    df_train, "./模型分析demo/v6-lgb/v6-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重和离散值
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    customized_variables=discrete_cols,
)

not_discrete_cols = df_train.dtypes[df_train.dtypes != object].index.tolist()
at.Analysis.model_on_data(
    df_train, "./模型分析demo/v6-lgb-oh/v6-lgb-oh.xlsx", test_data=df_test,
    data_flow={
        **data_params,
        **{
            "save_one_hot": True,  # 数据集仅保留原始数据，会自动添加"ORI_"
            "save_or_return": False,  # 跳过csv的io读写提升性能
            "exclude_column": ["ID", "weight"] + not_discrete_cols,  # 排除权重和数值变量
        },
    },
    model_flow={
        "response": "target", "split_col_name": "birth_year", "use_train_time": True,
        "exclude_column": ["ID", "weight"],  # 排除权重和离散值
        "add_info": "ID",  # 主键添加
        # 指定使用训练的class并不进行打分转化
        "model_type_path": "lightgbm.sklearn.LGBMClassifier", "convert_score": False,
        "filter_variable": False, # 数据one-hot之后变量名会变化，data_flow已经限制范围了，直接设置filter_variables能达到一样的效果
    }
)

at.Analysis.model_flow(
    df_train, "./模型分析demo/v7-lgb/v7-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    customized_parameter={
        "n_estimators": 200  #  默认100，尝试增加迭代次数
    }
)

# 首先安装torch，网速太慢的话请先下载再安装，不同平台自行修改安装命令，miniconda建议pip安装，安装命令来自：https://pytorch.org/get-started/locally/
# windows 我的笔记本有GPU
pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113
# linux 但我的VPS只有CPU
pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cpu
# 再安装skorch，来自：https://github.com/skorch-dev/skorch
pip install -U skorch

not_discrete_cols = df_train.dtypes[df_train.dtypes != object].index.tolist()
at.Analysis.model_flow(
    df_train, "./模型分析demo/v8-torch/v8-torch.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    model_func_definition=run_torch_net,
    customized_variables=not_discrete_cols,
    customized_parameter={
        "max_epochs": 10,
        "lr": 0.1,
    },
    precision=30,
)

    # 交叉验证相关
    # use_larger_training               选填，默认True，默认在N折时使用分割后较大的数据集来进行训练，正常不调整
    # enable_train_fold                 选填，默认True，是否在切片存在时，使用切片进行N折交叉验证
    # cv_inherit_range                  选填，默认False，交叉验证分段计算时是否继承建模的分段点

at.Analysis.model_flow(
    df_train, "./模型分析demo/v9-lgb/v9-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    customized_parameter={
        "n_estimators": [10, 20, 30, 40, 50],
        "learning_rate": [0.05, 0.08, 0.10]
    }
)

    # 模型参数搜索
    # cache_same_params                 选填，默认True，交叉验证搜索时缓存相同参数的模型搜索结果，不建议调整
    # model_search_target               选填，默认{"binary": "roc_auc_score", "regression": "mean_squared_error"}
    # model_search_params               选填，默认{"binary": ["mean / std", -1], "regression": ["mean * std", 0]}

at.Analysis.model_flow(
    df_train, "./模型分析demo/v10-lgb/v10-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    customized_parameter={
        "n_estimators": [10, 20, 30, 40, 50],
        "learning_rate": [0.05, 0.08, 0.10]
    },
    model_search_target={"binary": "ks"},
    model_search_params={"binary": ["max", -1]}
)

    # 模型参数搜索
    # model_search_method               选填，默认"grid"，参数搜索方式，参考范围__pattern__["search_method_range"]
    # early_stop_iteration              选填，默认50，交叉验证搜索时最后N轮迭代无提升则提前终止搜索，适用于所有算法
    # min_iteration_number              选填，默认2，model_search_number和early_stop_iteration允许的最小搜索迭代次数
    # stop_certainty_search             选填，默认False，是否对确定性搜索算法启用early_stop_iteration，指"order"/"grid"

at.Analysis.model_flow(
    df_train, "./模型分析demo/v11-lgb/v11-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    customized_parameter={
        "n_estimators": list(range(5, 200, 10)),
        "learning_rate": [i/100 for i in range(5, 15, 1)],
    }
)

    # auto_search_loop                  选填，默认3，自动cv参数循环的重复次数，"order"/"order-random"时启用
    # auto_search_limit                 选填，默认5，auto_search_loop的上限值，"order"/"order-random"时启用

at.Analysis.model_flow(
    df_train, "./模型分析demo/v12-lgb/v12-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    customized_parameter={
        "n_estimators": list(range(5, 200, 10)),
        "learning_rate": [i/100 for i in range(5, 15, 1)],
        "max_depth": [3, 4, 5, -1],
        "min_child_samples": list(range(20, 55, 5)),
        "min_child_weight": [i/1000 for i in range(1, 11, 1)],
    },
    model_search_method="order",
    model_search_params={"binary": ["max", -1]}
)

    # 模型参数搜索
    # model_search_number               选填，默认0.75，float为"grid"的百分比，int为迭代数，不适用于"order"/"grid"
    # random_search_number              选填，默认True，在数值参数的上下限随机搜索入参数值，不适用于"order"/"grid"
    # random_number_precision           选填，默认3，当启用random_search_number时，限制float保留的小数点位数，不影响int

at.Analysis.model_flow(
    df_train, "./模型分析demo/v13-lgb/v13-lgb.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="lightgbm.sklearn.LGBMClassifier",
    convert_score=False,
    customized_parameter={
        "n_estimators": list(range(5, 200, 10)),
        "learning_rate": [i/100 for i in range(5, 15, 1)],
        "max_depth": [3, 4, 5, -1],
        "min_child_samples": list(range(20, 55, 5)),
        "min_child_weight": [i/1000 for i in range(1, 11, 1)],
    },
    model_search_method="random",
    model_search_params={"binary": ["max", -1]},
)

    # 模型参数搜索
    # search_method_params              选填，默认{}，当入参model_search_method使用"hyperopt"/"skopt"函数时的额外入参    

at.Analysis.model_flow(
    df_train, "./模型分析demo/v14-knn/v14-knn.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    # 指定使用训练的class并不进行打分转化
    model_type_path="sklearn.neighbors.KNeighborsClassifier",
    convert_score=False,
    customized_parameter={
        "n_neighbors": [3, 4, 5, 6, 7, 8],
        "weights": ['uniform', 'distance'],
        "leaf_size": [20, 30, 40, 50],
    },
    model_search_method="tpe",
    model_search_params={"binary": ["max", -1]},
)

    # 评分卡相关
    # odds                              选填，默认1/15，None时为样本好坏比
    # precision                         选填，默认3，convert_score时默认为0
    # cut_method                        选填，默认"quantile"，可配置"cumsum"
    # display_ks                        选填，默认20，汇总展示的计算参数配置
    # base_score                        选填，默认600，打分卡转换时的基础分数
    # double_score                      选填，默认50，打分卡转换时分数的翻倍分数
    # include_right                     选填，默认True，数值分组时的边界，默认含右侧值
    # convert_score                     选填，默认True，是否将模型预测的概率转化为评分卡结果
    # keep_raw_score                    选填，默认True，在convert_score为True时，是否保留原始分数
    # save_score_desc                   选填，默认True，输出打分卡的生成逻辑到表格，会包含详细信息
    # auto_valid_convert                选填，默认True，检测convert_score为True时是否可行，并自动调整参数

    # 交叉矩阵分析
    # swap_compare_name                 选填，默认None，输入一列或多列与打分或概率进行交叉项分析
    # swap_length_limit                 选填，默认30，限制swap名称和离散值个数长度，避免绘图异常
    # maximum_swap_item                 选填，默认9，最大支持swap_item的数量，过多会导致性能问题
    # swap_precision                    选填，默认3，存在swap时的精度，不会随convert_score修改

df_train, df_test = df_train.copy(), df_test.copy()
df_train["Age-swap"], df_test["Age-swap"] = df_train["Age"].copy(), df_test["Age"].copy()
df_train["sample1"] = np.random.rand(df_train.index.size)
df_train["sample2"] = np.random.uniform(0, 1, df_train.index.size)
df_test["sample1"] = np.random.rand(df_test.index.size)
df_test["sample2"] = np.random.uniform(0, 1, df_test.index.size)
at.Analysis.model_on_data(
    df_train, "./模型分析demo/v15/v15.xlsx", test_data=df_test,
    data_flow={
        **data_params, **{
            "save_or_return": False,  # 跳过csv的io读写提升性能
            "add_info": ["ID", "sample1", "sample2", "Age-swap"],  # model_flow才能读到
        },
    },
    model_flow={
        "split_col_name": "birth_year", "use_train_time": True,
        "exclude_column": ["ID", "weight"],  # 排除权重
        "swap_compare_name": ["sample1", "sample2", "Age-swap"],  # 直接伪造数据假设这三个维度需要swap
    }
)

    # 模型定义
    # exists_proba_name                 选填，默认None，指定后会跳过建模过程，直接进行评估与绘图

df_train, df_test = df_train.copy(), df_test.copy()
df_train["sample1"] = np.random.rand(df_train.index.size)
df_train["sample2"] = np.random.uniform(0, 1, df_train.index.size)
df_test["sample1"] = np.random.rand(df_test.index.size)
df_test["sample2"] = np.random.uniform(0, 1, df_test.index.size)
at.Analysis.model_flow(
    df_train, "./模型分析demo/v16/v16.xlsx", test_data=df_test, 
    # 目标定义 & 切片定义
    response="target", split_col_name="birth_year", use_train_time=True,
    exclude_column=["ID", "weight"],  # 排除权重
    add_info="ID",  # 主键添加
    exists_proba_name="Age",  # 假设此处Age是需要进行评估的模型结果
    swap_compare_name=["sample1", "sample2"],  # 直接伪造数据假设这两个维度需要swap
)

    # data_bar_cols                     选填，默认["rate", "woe", "vif", "score", "corr"]，默认条件格式的列

    # 分析输出相关
    # drawing                           选填，默认True，输出可视化绘图结果
    # add_info                          选填，默认None，添加列，支持str和list
    # save_vif                          选填，默认True，计算变量的vif输出结果
    # save_corr                         选填，默认True，输出变量的相关性系数表的结果
    # save_json                         选填，默认True，将计算结果配置文件输出为json
    # add_woe_iv                        选填，默认False，是否在表中展示分组的woe和iv值
    # add_ind_ks                        选填，默认True，计算将不确定值视为good的ks数值
    # add_cap_info                      选填，默认True，是否在表中展示组内占比的百分比列
    # add_cum_left                      选填，默认True，是否在表中展示累计与剩余目标占比
    # add_cum_info                      选填，默认True，是否在表中展示累计个数与累计占比
    # add_cum_odds                      选填，默认True，是否在结果表中展示累计好坏客户比
    # add_gini_lift                     选填，默认True，是否在表中展示gini和lift的计算值

    # 模型文件输出
    # save_model_pkl                    选填，默认True，将计算的模型的结果存储为pkl文件导出
    # save_model_pmml                   选填，默认True，使用sklearn2pmml来转化模型为pmml模型
    # save_score_pmml                   选填，默认True，解析评分卡分数并转化为对应的pmml文件
    # save_stepwise_pkl                 选填，默认False，输出符合筛选的逐步回归的所有变量组合
    # save_cv_model_pkl                 选填，默认False，将enable_train_fold的模型结果存为pkl文件
    # save_cv_search_pkl                选填，默认False，将交叉验证中间过程的搜索参数等保存为pkl文件

    # 分数输出相关
    # save_score_py                     选填，默认True，解析分数为对应的py部署逻辑
    # save_score_sql                    选填，默认True，解析分数为对应的sql部署逻辑
    # sql_has_boolean                   选填，默认True，是否按bool值转化score中的字符串
    # else_score_value                  选填，默认-999999，模型打分逻辑不包含时的异常分值

    # 模型评分输出
    # save_total_score                  选填，默认False，输出输入数据的总分以及概率到csv文件
    # save_detail_score                 选填，默认False，输出输入数据的明细打分结果到csv文件
    # save_raw_dataframe                选填，默认False，输出输入数据的筛选原始数据到csv文件

at.Analysis.model_flow(
    df_train, "./模型分析demo/vr-torch/vr-torch.xlsx", test_data=df_test, 
    recover_from_json="./模型分析demo/v8-torch/Model_v8-torch.json"
)

    # alpha_tools.Analysis.model_on_data参数
    # union_variable                    选填，默认False，仅恢复入模参数指标，True时在recover_path还原时恢复全量指标

ori_name = "./模型分析demo/v4-lgb/v4-lgb.xlsx"
new_output = "./模型分析demo/vr-lgb/vr-lgb.xlsx"
at.Analysis.model_flow(
    df_train, new_output,
    test_data=[df_test, df_data], train_name="开发", test_names=["测试", "全量"],
    recover_path=ori_name, 
    # 继承 v4 并进行参数搜索，映射到多个数据集
    customized_parameter={
        "n_estimators": [10, 20, 30, 40, 50],
        "learning_rate": [0.05, 0.08, 0.10]
    }
)
# 打包结果
at.dt.Api.zip_dir_files("./模型分析demo/vr-lgb.zip", "./模型分析demo/vr-lgb")

at.Report.create_model_report(
    "./模型分析demo/vm-模型对比/vm-模型对比.xlsx", [
        "./模型分析demo/v1-lgb/v1-lgb.xlsx", "./模型分析demo/v2-lr/v2-lr.xlsx",
        "./模型分析demo/v3-lgb/v3-lgb.xlsx", "./模型分析demo/v4-lgb/v4-lgb.xlsx",
        "./模型分析demo/v5-gls/v5-gls.xlsx", "./模型分析demo/v6-lgb/v6-lgb.xlsx",
        "./模型分析demo/v6-lgb-oh/v6-lgb-oh.xlsx", "./模型分析demo/v7-lgb/v7-lgb.xlsx",
        "./模型分析demo/v8-torch/v8-torch.xlsx", "./模型分析demo/v9-lgb/v9-lgb.xlsx",
        "./模型分析demo/v10-lgb/v10-lgb.xlsx", "./模型分析demo/v11-lgb/v11-lgb.xlsx",
        "./模型分析demo/v12-lgb/v12-lgb.xlsx", "./模型分析demo/v13-lgb/v13-lgb.xlsx",
        "./模型分析demo/v14-knn/v14-knn.xlsx",
    ], [
        "v1-lgb", "v2-lr", "v3-lgb", "v4-lgb", "v5-gls",
        "v6-lgb", "v6-lgb-oh", "v7-lgb", "v8-torch", "v9-lgb",
        "v10-lgb", "v11-lgb", "v12-lgb", "v13-lgb", "v14-knn",
    ]
)